diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_core.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_core.rs
index be31d2d8fe..082d27f5a9 100644
--- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_core.rs
+++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_core.rs
@@ -9,34 +9,29 @@ use bevy_mod_scripting_core::bindings::{
         namespace::NamespaceBuilder,
     },
 };
+use bevy_mod_scripting_derive::script_bindings;
 use crate::*;
 pub struct BevyCoreScriptingPlugin;
+#[script_bindings(remote, name = "name")]
+impl bevy::core::prelude::Name {
+    fn clone(_self: Ref<bevy::core::prelude::Name>) {
+        let output: Val<bevy::core::prelude::Name> = <bevy::core::prelude::Name as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::core::prelude::Name>, other: Ref<bevy::core::prelude::Name>) {
+        let output: bool = <bevy::core::prelude::Name as std::cmp::PartialEq<
+            bevy::core::prelude::Name,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
 impl ::bevy::app::Plugin for BevyCoreScriptingPlugin {
     fn build(&self, app: &mut ::bevy::prelude::App) {
         let mut world = app.world_mut();
-        NamespaceBuilder::<::bevy::core::prelude::Name>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::core::prelude::Name>| {
-                    let output: Val<bevy::core::prelude::Name> = <bevy::core::prelude::Name as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::core::prelude::Name>,
-                    other: Ref<bevy::core::prelude::Name>|
-                {
-                    let output: bool = <bevy::core::prelude::Name as std::cmp::PartialEq<
-                        bevy::core::prelude::Name,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
+        register_name(&mut world);
     }
 }
diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_ecs.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_ecs.rs
index a5881aedc4..b87c5fe438 100644
--- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_ecs.rs
+++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_ecs.rs
@@ -9,376 +9,289 @@ use bevy_mod_scripting_core::bindings::{
         namespace::NamespaceBuilder,
     },
 };
+use bevy_mod_scripting_derive::script_bindings;
 use crate::*;
 pub struct BevyEcsScriptingPlugin;
-impl ::bevy::app::Plugin for BevyEcsScriptingPlugin {
-    fn build(&self, app: &mut ::bevy::prelude::App) {
-        let mut world = app.world_mut();
-        NamespaceBuilder::<::bevy::ecs::entity::Entity>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::ecs::entity::Entity>| {
-                    let output: Val<bevy::ecs::entity::Entity> = <bevy::ecs::entity::Entity as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::ecs::entity::Entity>,
-                    other: Ref<bevy::ecs::entity::Entity>|
-                {
-                    let output: bool = <bevy::ecs::entity::Entity as std::cmp::PartialEq<
-                        bevy::ecs::entity::Entity,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_bits",
-                |bits: u64| {
-                    let output: Val<bevy::ecs::entity::Entity> = bevy::ecs::entity::Entity::from_bits(
-                            bits,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_raw",
-                |index: u32| {
-                    let output: Val<bevy::ecs::entity::Entity> = bevy::ecs::entity::Entity::from_raw(
-                            index,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "generation",
-                |_self: Val<bevy::ecs::entity::Entity>| {
-                    let output: u32 = bevy::ecs::entity::Entity::generation(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
+#[script_bindings(remote, name = "entity")]
+impl bevy::ecs::entity::Entity {
+    fn clone(_self: Ref<bevy::ecs::entity::Entity>) {
+        let output: Val<bevy::ecs::entity::Entity> = <bevy::ecs::entity::Entity as std::clone::Clone>::clone(
+                &_self,
             )
-            .register(
-                "index",
-                |_self: Val<bevy::ecs::entity::Entity>| {
-                    let output: u32 = bevy::ecs::entity::Entity::index(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_bits",
-                |_self: Val<bevy::ecs::entity::Entity>| {
-                    let output: u64 = bevy::ecs::entity::Entity::to_bits(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::ecs::world::OnAdd>::new(world);
-        NamespaceBuilder::<::bevy::ecs::world::OnInsert>::new(world);
-        NamespaceBuilder::<::bevy::ecs::world::OnRemove>::new(world);
-        NamespaceBuilder::<::bevy::ecs::world::OnReplace>::new(world);
-        NamespaceBuilder::<::bevy::ecs::component::ComponentId>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::ecs::component::ComponentId>| {
-                    let output: () = <bevy::ecs::component::ComponentId as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::ecs::entity::Entity>, other: Ref<bevy::ecs::entity::Entity>) {
+        let output: bool = <bevy::ecs::entity::Entity as std::cmp::PartialEq<
+            bevy::ecs::entity::Entity,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_bits(bits: u64) {
+        let output: Val<bevy::ecs::entity::Entity> = bevy::ecs::entity::Entity::from_bits(
+                bits,
             )
-            .register(
-                "clone",
-                |_self: Ref<bevy::ecs::component::ComponentId>| {
-                    let output: Val<bevy::ecs::component::ComponentId> = <bevy::ecs::component::ComponentId as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn from_raw(index: u32) {
+        let output: Val<bevy::ecs::entity::Entity> = bevy::ecs::entity::Entity::from_raw(
+                index,
             )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::ecs::component::ComponentId>,
-                    other: Ref<bevy::ecs::component::ComponentId>|
-                {
-                    let output: bool = <bevy::ecs::component::ComponentId as std::cmp::PartialEq<
-                        bevy::ecs::component::ComponentId,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn generation(_self: Val<bevy::ecs::entity::Entity>) {
+        let output: u32 = bevy::ecs::entity::Entity::generation(_self.into_inner())
+            .into();
+        output
+    }
+    fn index(_self: Val<bevy::ecs::entity::Entity>) {
+        let output: u32 = bevy::ecs::entity::Entity::index(_self.into_inner()).into();
+        output
+    }
+    fn to_bits(_self: Val<bevy::ecs::entity::Entity>) {
+        let output: u64 = bevy::ecs::entity::Entity::to_bits(_self.into_inner()).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "on_add")]
+impl bevy::ecs::world::OnAdd {}
+#[script_bindings(remote, name = "on_insert")]
+impl bevy::ecs::world::OnInsert {}
+#[script_bindings(remote, name = "on_remove")]
+impl bevy::ecs::world::OnRemove {}
+#[script_bindings(remote, name = "on_replace")]
+impl bevy::ecs::world::OnReplace {}
+#[script_bindings(remote, name = "component_id")]
+impl bevy::ecs::component::ComponentId {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::ecs::component::ComponentId>) {
+        let output: () = <bevy::ecs::component::ComponentId as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
             )
-            .register(
-                "index",
-                |_self: Val<bevy::ecs::component::ComponentId>| {
-                    let output: usize = bevy::ecs::component::ComponentId::index(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::ecs::component::ComponentId>) {
+        let output: Val<bevy::ecs::component::ComponentId> = <bevy::ecs::component::ComponentId as std::clone::Clone>::clone(
+                &_self,
             )
-            .register(
-                "new",
-                |index: usize| {
-                    let output: Val<bevy::ecs::component::ComponentId> = bevy::ecs::component::ComponentId::new(
-                            index,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::ecs::component::Tick>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::ecs::component::Tick>| {
-                    let output: () = <bevy::ecs::component::Tick as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::ecs::component::ComponentId>,
+        other: Ref<bevy::ecs::component::ComponentId>,
+    ) {
+        let output: bool = <bevy::ecs::component::ComponentId as std::cmp::PartialEq<
+            bevy::ecs::component::ComponentId,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn index(_self: Val<bevy::ecs::component::ComponentId>) {
+        let output: usize = bevy::ecs::component::ComponentId::index(_self.into_inner())
+            .into();
+        output
+    }
+    fn new(index: usize) {
+        let output: Val<bevy::ecs::component::ComponentId> = bevy::ecs::component::ComponentId::new(
+                index,
             )
-            .register(
-                "clone",
-                |_self: Ref<bevy::ecs::component::Tick>| {
-                    let output: Val<bevy::ecs::component::Tick> = <bevy::ecs::component::Tick as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "tick")]
+impl bevy::ecs::component::Tick {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::ecs::component::Tick>) {
+        let output: () = <bevy::ecs::component::Tick as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
             )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::ecs::component::Tick>,
-                    other: Ref<bevy::ecs::component::Tick>|
-                {
-                    let output: bool = <bevy::ecs::component::Tick as std::cmp::PartialEq<
-                        bevy::ecs::component::Tick,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::ecs::component::Tick>) {
+        let output: Val<bevy::ecs::component::Tick> = <bevy::ecs::component::Tick as std::clone::Clone>::clone(
+                &_self,
             )
-            .register(
-                "get",
-                |_self: Val<bevy::ecs::component::Tick>| {
-                    let output: u32 = bevy::ecs::component::Tick::get(_self.into_inner())
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::ecs::component::Tick>,
+        other: Ref<bevy::ecs::component::Tick>,
+    ) {
+        let output: bool = <bevy::ecs::component::Tick as std::cmp::PartialEq<
+            bevy::ecs::component::Tick,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn get(_self: Val<bevy::ecs::component::Tick>) {
+        let output: u32 = bevy::ecs::component::Tick::get(_self.into_inner()).into();
+        output
+    }
+    fn is_newer_than(
+        _self: Val<bevy::ecs::component::Tick>,
+        last_run: Val<bevy::ecs::component::Tick>,
+        this_run: Val<bevy::ecs::component::Tick>,
+    ) {
+        let output: bool = bevy::ecs::component::Tick::is_newer_than(
+                _self.into_inner(),
+                last_run.into_inner(),
+                this_run.into_inner(),
             )
-            .register(
-                "is_newer_than",
-                |
-                    _self: Val<bevy::ecs::component::Tick>,
-                    last_run: Val<bevy::ecs::component::Tick>,
-                    this_run: Val<bevy::ecs::component::Tick>|
-                {
-                    let output: bool = bevy::ecs::component::Tick::is_newer_than(
-                            _self.into_inner(),
-                            last_run.into_inner(),
-                            this_run.into_inner(),
-                        )
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn new(tick: u32) {
+        let output: Val<bevy::ecs::component::Tick> = bevy::ecs::component::Tick::new(
+                tick,
             )
-            .register(
-                "new",
-                |tick: u32| {
-                    let output: Val<bevy::ecs::component::Tick> = bevy::ecs::component::Tick::new(
-                            tick,
-                        )
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn set(mut _self: Mut<bevy::ecs::component::Tick>, tick: u32) {
+        let output: () = bevy::ecs::component::Tick::set(&mut _self, tick).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "component_ticks")]
+impl bevy::ecs::component::ComponentTicks {
+    fn clone(_self: Ref<bevy::ecs::component::ComponentTicks>) {
+        let output: Val<bevy::ecs::component::ComponentTicks> = <bevy::ecs::component::ComponentTicks as std::clone::Clone>::clone(
+                &_self,
             )
-            .register(
-                "set",
-                |mut _self: Mut<bevy::ecs::component::Tick>, tick: u32| {
-                    let output: () = bevy::ecs::component::Tick::set(&mut _self, tick)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::ecs::component::ComponentTicks>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::ecs::component::ComponentTicks>| {
-                    let output: Val<bevy::ecs::component::ComponentTicks> = <bevy::ecs::component::ComponentTicks as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn is_added(
+        _self: Ref<bevy::ecs::component::ComponentTicks>,
+        last_run: Val<bevy::ecs::component::Tick>,
+        this_run: Val<bevy::ecs::component::Tick>,
+    ) {
+        let output: bool = bevy::ecs::component::ComponentTicks::is_added(
+                &_self,
+                last_run.into_inner(),
+                this_run.into_inner(),
             )
-            .register(
-                "is_added",
-                |
-                    _self: Ref<bevy::ecs::component::ComponentTicks>,
-                    last_run: Val<bevy::ecs::component::Tick>,
-                    this_run: Val<bevy::ecs::component::Tick>|
-                {
-                    let output: bool = bevy::ecs::component::ComponentTicks::is_added(
-                            &_self,
-                            last_run.into_inner(),
-                            this_run.into_inner(),
-                        )
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn is_changed(
+        _self: Ref<bevy::ecs::component::ComponentTicks>,
+        last_run: Val<bevy::ecs::component::Tick>,
+        this_run: Val<bevy::ecs::component::Tick>,
+    ) {
+        let output: bool = bevy::ecs::component::ComponentTicks::is_changed(
+                &_self,
+                last_run.into_inner(),
+                this_run.into_inner(),
             )
-            .register(
-                "is_changed",
-                |
-                    _self: Ref<bevy::ecs::component::ComponentTicks>,
-                    last_run: Val<bevy::ecs::component::Tick>,
-                    this_run: Val<bevy::ecs::component::Tick>|
-                {
-                    let output: bool = bevy::ecs::component::ComponentTicks::is_changed(
-                            &_self,
-                            last_run.into_inner(),
-                            this_run.into_inner(),
-                        )
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn new(change_tick: Val<bevy::ecs::component::Tick>) {
+        let output: Val<bevy::ecs::component::ComponentTicks> = bevy::ecs::component::ComponentTicks::new(
+                change_tick.into_inner(),
             )
-            .register(
-                "new",
-                |change_tick: Val<bevy::ecs::component::Tick>| {
-                    let output: Val<bevy::ecs::component::ComponentTicks> = bevy::ecs::component::ComponentTicks::new(
-                            change_tick.into_inner(),
-                        )
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn set_changed(
+        mut _self: Mut<bevy::ecs::component::ComponentTicks>,
+        change_tick: Val<bevy::ecs::component::Tick>,
+    ) {
+        let output: () = bevy::ecs::component::ComponentTicks::set_changed(
+                &mut _self,
+                change_tick.into_inner(),
             )
-            .register(
-                "set_changed",
-                |
-                    mut _self: Mut<bevy::ecs::component::ComponentTicks>,
-                    change_tick: Val<bevy::ecs::component::Tick>|
-                {
-                    let output: () = bevy::ecs::component::ComponentTicks::set_changed(
-                            &mut _self,
-                            change_tick.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::ecs::identifier::Identifier>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::ecs::identifier::Identifier>| {
-                    let output: Val<bevy::ecs::identifier::Identifier> = <bevy::ecs::identifier::Identifier as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "identifier")]
+impl bevy::ecs::identifier::Identifier {
+    fn clone(_self: Ref<bevy::ecs::identifier::Identifier>) {
+        let output: Val<bevy::ecs::identifier::Identifier> = <bevy::ecs::identifier::Identifier as std::clone::Clone>::clone(
+                &_self,
             )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::ecs::identifier::Identifier>,
-                    other: Ref<bevy::ecs::identifier::Identifier>|
-                {
-                    let output: bool = <bevy::ecs::identifier::Identifier as std::cmp::PartialEq<
-                        bevy::ecs::identifier::Identifier,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::ecs::identifier::Identifier>,
+        other: Ref<bevy::ecs::identifier::Identifier>,
+    ) {
+        let output: bool = <bevy::ecs::identifier::Identifier as std::cmp::PartialEq<
+            bevy::ecs::identifier::Identifier,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_bits(value: u64) {
+        let output: Val<bevy::ecs::identifier::Identifier> = bevy::ecs::identifier::Identifier::from_bits(
+                value,
             )
-            .register(
-                "from_bits",
-                |value: u64| {
-                    let output: Val<bevy::ecs::identifier::Identifier> = bevy::ecs::identifier::Identifier::from_bits(
-                            value,
-                        )
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn low(_self: Val<bevy::ecs::identifier::Identifier>) {
+        let output: u32 = bevy::ecs::identifier::Identifier::low(_self.into_inner())
+            .into();
+        output
+    }
+    fn masked_high(_self: Val<bevy::ecs::identifier::Identifier>) {
+        let output: u32 = bevy::ecs::identifier::Identifier::masked_high(
+                _self.into_inner(),
             )
-            .register(
-                "low",
-                |_self: Val<bevy::ecs::identifier::Identifier>| {
-                    let output: u32 = bevy::ecs::identifier::Identifier::low(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn to_bits(_self: Val<bevy::ecs::identifier::Identifier>) {
+        let output: u64 = bevy::ecs::identifier::Identifier::to_bits(_self.into_inner())
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "entity_hash")]
+impl bevy::ecs::entity::EntityHash {
+    fn clone(_self: Ref<bevy::ecs::entity::EntityHash>) {
+        let output: Val<bevy::ecs::entity::EntityHash> = <bevy::ecs::entity::EntityHash as std::clone::Clone>::clone(
+                &_self,
             )
-            .register(
-                "masked_high",
-                |_self: Val<bevy::ecs::identifier::Identifier>| {
-                    let output: u32 = bevy::ecs::identifier::Identifier::masked_high(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "removed_component_entity")]
+impl bevy::ecs::removal_detection::RemovedComponentEntity {
+    fn clone(_self: Ref<bevy::ecs::removal_detection::RemovedComponentEntity>) {
+        let output: Val<bevy::ecs::removal_detection::RemovedComponentEntity> = <bevy::ecs::removal_detection::RemovedComponentEntity as std::clone::Clone>::clone(
+                &_self,
             )
-            .register(
-                "to_bits",
-                |_self: Val<bevy::ecs::identifier::Identifier>| {
-                    let output: u64 = bevy::ecs::identifier::Identifier::to_bits(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::ecs::entity::EntityHash>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::ecs::entity::EntityHash>| {
-                    let output: Val<bevy::ecs::entity::EntityHash> = <bevy::ecs::entity::EntityHash as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<
-            ::bevy::ecs::removal_detection::RemovedComponentEntity,
-        >::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::ecs::removal_detection::RemovedComponentEntity>| {
-                    let output: Val<
-                        bevy::ecs::removal_detection::RemovedComponentEntity,
-                    > = <bevy::ecs::removal_detection::RemovedComponentEntity as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::ecs::system::SystemIdMarker>::new(world);
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "system_id_marker")]
+impl bevy::ecs::system::SystemIdMarker {}
+impl ::bevy::app::Plugin for BevyEcsScriptingPlugin {
+    fn build(&self, app: &mut ::bevy::prelude::App) {
+        let mut world = app.world_mut();
+        register_entity(&mut world);
+        register_on_add(&mut world);
+        register_on_insert(&mut world);
+        register_on_remove(&mut world);
+        register_on_replace(&mut world);
+        register_component_id(&mut world);
+        register_tick(&mut world);
+        register_component_ticks(&mut world);
+        register_identifier(&mut world);
+        register_entity_hash(&mut world);
+        register_removed_component_entity(&mut world);
+        register_system_id_marker(&mut world);
     }
 }
diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_hierarchy.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_hierarchy.rs
index 45f345a6ee..778559f8f3 100644
--- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_hierarchy.rs
+++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_hierarchy.rs
@@ -9,95 +9,84 @@ use bevy_mod_scripting_core::bindings::{
         namespace::NamespaceBuilder,
     },
 };
+use bevy_mod_scripting_derive::script_bindings;
 use crate::*;
 pub struct BevyHierarchyScriptingPlugin;
-impl ::bevy::app::Plugin for BevyHierarchyScriptingPlugin {
-    fn build(&self, app: &mut ::bevy::prelude::App) {
-        let mut world = app.world_mut();
-        NamespaceBuilder::<::bevy::hierarchy::prelude::Children>::new(world)
-            .register(
-                "swap",
-                |
-                    mut _self: Mut<bevy::hierarchy::prelude::Children>,
-                    a_index: usize,
-                    b_index: usize|
-                {
-                    let output: () = bevy::hierarchy::prelude::Children::swap(
-                            &mut _self,
-                            a_index,
-                            b_index,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::hierarchy::prelude::Parent>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::hierarchy::prelude::Parent>| {
-                    let output: () = <bevy::hierarchy::prelude::Parent as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
+#[script_bindings(remote, name = "children")]
+impl bevy::hierarchy::prelude::Children {
+    fn swap(
+        mut _self: Mut<bevy::hierarchy::prelude::Children>,
+        a_index: usize,
+        b_index: usize,
+    ) {
+        let output: () = bevy::hierarchy::prelude::Children::swap(
+                &mut _self,
+                a_index,
+                b_index,
             )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::hierarchy::prelude::Parent>,
-                    other: Ref<bevy::hierarchy::prelude::Parent>|
-                {
-                    let output: bool = <bevy::hierarchy::prelude::Parent as std::cmp::PartialEq<
-                        bevy::hierarchy::prelude::Parent,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "parent")]
+impl bevy::hierarchy::prelude::Parent {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::hierarchy::prelude::Parent>) {
+        let output: () = <bevy::hierarchy::prelude::Parent as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
             )
-            .register(
-                "get",
-                |_self: Ref<bevy::hierarchy::prelude::Parent>| {
-                    let output: Val<bevy::ecs::entity::Entity> = bevy::hierarchy::prelude::Parent::get(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::hierarchy::HierarchyEvent>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::hierarchy::HierarchyEvent>| {
-                    let output: () = <bevy::hierarchy::HierarchyEvent as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::hierarchy::prelude::Parent>,
+        other: Ref<bevy::hierarchy::prelude::Parent>,
+    ) {
+        let output: bool = <bevy::hierarchy::prelude::Parent as std::cmp::PartialEq<
+            bevy::hierarchy::prelude::Parent,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn get(_self: Ref<bevy::hierarchy::prelude::Parent>) {
+        let output: Val<bevy::ecs::entity::Entity> = bevy::hierarchy::prelude::Parent::get(
+                &_self,
             )
-            .register(
-                "clone",
-                |_self: Ref<bevy::hierarchy::HierarchyEvent>| {
-                    let output: Val<bevy::hierarchy::HierarchyEvent> = <bevy::hierarchy::HierarchyEvent as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "hierarchy_event")]
+impl bevy::hierarchy::HierarchyEvent {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::hierarchy::HierarchyEvent>) {
+        let output: () = <bevy::hierarchy::HierarchyEvent as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
             )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::hierarchy::HierarchyEvent>,
-                    other: Ref<bevy::hierarchy::HierarchyEvent>|
-                {
-                    let output: bool = <bevy::hierarchy::HierarchyEvent as std::cmp::PartialEq<
-                        bevy::hierarchy::HierarchyEvent,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::hierarchy::HierarchyEvent>) {
+        let output: Val<bevy::hierarchy::HierarchyEvent> = <bevy::hierarchy::HierarchyEvent as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::hierarchy::HierarchyEvent>,
+        other: Ref<bevy::hierarchy::HierarchyEvent>,
+    ) {
+        let output: bool = <bevy::hierarchy::HierarchyEvent as std::cmp::PartialEq<
+            bevy::hierarchy::HierarchyEvent,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+impl ::bevy::app::Plugin for BevyHierarchyScriptingPlugin {
+    fn build(&self, app: &mut ::bevy::prelude::App) {
+        let mut world = app.world_mut();
+        register_children(&mut world);
+        register_parent(&mut world);
+        register_hierarchy_event(&mut world);
     }
 }
diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_input.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_input.rs
index 7a041086d2..f67a167e81 100644
--- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_input.rs
+++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_input.rs
@@ -9,1530 +9,1248 @@ use bevy_mod_scripting_core::bindings::{
         namespace::NamespaceBuilder,
     },
 };
+use bevy_mod_scripting_derive::script_bindings;
 use crate::*;
 pub struct BevyInputScriptingPlugin;
+#[script_bindings(remote, name = "gamepad")]
+impl bevy::input::gamepad::Gamepad {
+    fn dpad(_self: Ref<bevy::input::gamepad::Gamepad>) {
+        let output: Val<bevy::math::Vec2> = bevy::input::gamepad::Gamepad::dpad(&_self)
+            .into();
+        output
+    }
+    fn just_pressed(
+        _self: Ref<bevy::input::gamepad::Gamepad>,
+        button_type: Val<bevy::input::gamepad::GamepadButton>,
+    ) {
+        let output: bool = bevy::input::gamepad::Gamepad::just_pressed(
+                &_self,
+                button_type.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn just_released(
+        _self: Ref<bevy::input::gamepad::Gamepad>,
+        button_type: Val<bevy::input::gamepad::GamepadButton>,
+    ) {
+        let output: bool = bevy::input::gamepad::Gamepad::just_released(
+                &_self,
+                button_type.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn left_stick(_self: Ref<bevy::input::gamepad::Gamepad>) {
+        let output: Val<bevy::math::Vec2> = bevy::input::gamepad::Gamepad::left_stick(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn pressed(
+        _self: Ref<bevy::input::gamepad::Gamepad>,
+        button_type: Val<bevy::input::gamepad::GamepadButton>,
+    ) {
+        let output: bool = bevy::input::gamepad::Gamepad::pressed(
+                &_self,
+                button_type.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn product_id(_self: Ref<bevy::input::gamepad::Gamepad>) {
+        let output: std::option::Option<u16> = bevy::input::gamepad::Gamepad::product_id(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn right_stick(_self: Ref<bevy::input::gamepad::Gamepad>) {
+        let output: Val<bevy::math::Vec2> = bevy::input::gamepad::Gamepad::right_stick(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn vendor_id(_self: Ref<bevy::input::gamepad::Gamepad>) {
+        let output: std::option::Option<u16> = bevy::input::gamepad::Gamepad::vendor_id(
+                &_self,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "gamepad_axis")]
+impl bevy::input::gamepad::GamepadAxis {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::input::gamepad::GamepadAxis>) {
+        let output: () = <bevy::input::gamepad::GamepadAxis as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::input::gamepad::GamepadAxis>) {
+        let output: Val<bevy::input::gamepad::GamepadAxis> = <bevy::input::gamepad::GamepadAxis as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::gamepad::GamepadAxis>,
+        other: Ref<bevy::input::gamepad::GamepadAxis>,
+    ) {
+        let output: bool = <bevy::input::gamepad::GamepadAxis as std::cmp::PartialEq<
+            bevy::input::gamepad::GamepadAxis,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "gamepad_button")]
+impl bevy::input::gamepad::GamepadButton {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::input::gamepad::GamepadButton>) {
+        let output: () = <bevy::input::gamepad::GamepadButton as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::input::gamepad::GamepadButton>) {
+        let output: Val<bevy::input::gamepad::GamepadButton> = <bevy::input::gamepad::GamepadButton as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::gamepad::GamepadButton>,
+        other: Ref<bevy::input::gamepad::GamepadButton>,
+    ) {
+        let output: bool = <bevy::input::gamepad::GamepadButton as std::cmp::PartialEq<
+            bevy::input::gamepad::GamepadButton,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "gamepad_settings")]
+impl bevy::input::gamepad::GamepadSettings {
+    fn clone(_self: Ref<bevy::input::gamepad::GamepadSettings>) {
+        let output: Val<bevy::input::gamepad::GamepadSettings> = <bevy::input::gamepad::GamepadSettings as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "key_code")]
+impl bevy::input::keyboard::KeyCode {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::input::keyboard::KeyCode>) {
+        let output: () = <bevy::input::keyboard::KeyCode as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::input::keyboard::KeyCode>) {
+        let output: Val<bevy::input::keyboard::KeyCode> = <bevy::input::keyboard::KeyCode as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::keyboard::KeyCode>,
+        other: Ref<bevy::input::keyboard::KeyCode>,
+    ) {
+        let output: bool = <bevy::input::keyboard::KeyCode as std::cmp::PartialEq<
+            bevy::input::keyboard::KeyCode,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "mouse_button")]
+impl bevy::input::mouse::MouseButton {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::input::mouse::MouseButton>) {
+        let output: () = <bevy::input::mouse::MouseButton as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::input::mouse::MouseButton>) {
+        let output: Val<bevy::input::mouse::MouseButton> = <bevy::input::mouse::MouseButton as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::mouse::MouseButton>,
+        other: Ref<bevy::input::mouse::MouseButton>,
+    ) {
+        let output: bool = <bevy::input::mouse::MouseButton as std::cmp::PartialEq<
+            bevy::input::mouse::MouseButton,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "touch_input")]
+impl bevy::input::touch::TouchInput {
+    fn clone(_self: Ref<bevy::input::touch::TouchInput>) {
+        let output: Val<bevy::input::touch::TouchInput> = <bevy::input::touch::TouchInput as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::touch::TouchInput>,
+        other: Ref<bevy::input::touch::TouchInput>,
+    ) {
+        let output: bool = <bevy::input::touch::TouchInput as std::cmp::PartialEq<
+            bevy::input::touch::TouchInput,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "keyboard_focus_lost")]
+impl bevy::input::keyboard::KeyboardFocusLost {
+    fn assert_receiver_is_total_eq(
+        _self: Ref<bevy::input::keyboard::KeyboardFocusLost>,
+    ) {
+        let output: () = <bevy::input::keyboard::KeyboardFocusLost as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::input::keyboard::KeyboardFocusLost>) {
+        let output: Val<bevy::input::keyboard::KeyboardFocusLost> = <bevy::input::keyboard::KeyboardFocusLost as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::keyboard::KeyboardFocusLost>,
+        other: Ref<bevy::input::keyboard::KeyboardFocusLost>,
+    ) {
+        let output: bool = <bevy::input::keyboard::KeyboardFocusLost as std::cmp::PartialEq<
+            bevy::input::keyboard::KeyboardFocusLost,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "keyboard_input")]
+impl bevy::input::keyboard::KeyboardInput {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::input::keyboard::KeyboardInput>) {
+        let output: () = <bevy::input::keyboard::KeyboardInput as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::input::keyboard::KeyboardInput>) {
+        let output: Val<bevy::input::keyboard::KeyboardInput> = <bevy::input::keyboard::KeyboardInput as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::keyboard::KeyboardInput>,
+        other: Ref<bevy::input::keyboard::KeyboardInput>,
+    ) {
+        let output: bool = <bevy::input::keyboard::KeyboardInput as std::cmp::PartialEq<
+            bevy::input::keyboard::KeyboardInput,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "accumulated_mouse_motion")]
+impl bevy::input::mouse::AccumulatedMouseMotion {
+    fn clone(_self: Ref<bevy::input::mouse::AccumulatedMouseMotion>) {
+        let output: Val<bevy::input::mouse::AccumulatedMouseMotion> = <bevy::input::mouse::AccumulatedMouseMotion as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::mouse::AccumulatedMouseMotion>,
+        other: Ref<bevy::input::mouse::AccumulatedMouseMotion>,
+    ) {
+        let output: bool = <bevy::input::mouse::AccumulatedMouseMotion as std::cmp::PartialEq<
+            bevy::input::mouse::AccumulatedMouseMotion,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "accumulated_mouse_scroll")]
+impl bevy::input::mouse::AccumulatedMouseScroll {
+    fn clone(_self: Ref<bevy::input::mouse::AccumulatedMouseScroll>) {
+        let output: Val<bevy::input::mouse::AccumulatedMouseScroll> = <bevy::input::mouse::AccumulatedMouseScroll as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::mouse::AccumulatedMouseScroll>,
+        other: Ref<bevy::input::mouse::AccumulatedMouseScroll>,
+    ) {
+        let output: bool = <bevy::input::mouse::AccumulatedMouseScroll as std::cmp::PartialEq<
+            bevy::input::mouse::AccumulatedMouseScroll,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "mouse_button_input")]
+impl bevy::input::mouse::MouseButtonInput {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::input::mouse::MouseButtonInput>) {
+        let output: () = <bevy::input::mouse::MouseButtonInput as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::input::mouse::MouseButtonInput>) {
+        let output: Val<bevy::input::mouse::MouseButtonInput> = <bevy::input::mouse::MouseButtonInput as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::mouse::MouseButtonInput>,
+        other: Ref<bevy::input::mouse::MouseButtonInput>,
+    ) {
+        let output: bool = <bevy::input::mouse::MouseButtonInput as std::cmp::PartialEq<
+            bevy::input::mouse::MouseButtonInput,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "mouse_motion")]
+impl bevy::input::mouse::MouseMotion {
+    fn clone(_self: Ref<bevy::input::mouse::MouseMotion>) {
+        let output: Val<bevy::input::mouse::MouseMotion> = <bevy::input::mouse::MouseMotion as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::mouse::MouseMotion>,
+        other: Ref<bevy::input::mouse::MouseMotion>,
+    ) {
+        let output: bool = <bevy::input::mouse::MouseMotion as std::cmp::PartialEq<
+            bevy::input::mouse::MouseMotion,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "mouse_wheel")]
+impl bevy::input::mouse::MouseWheel {
+    fn clone(_self: Ref<bevy::input::mouse::MouseWheel>) {
+        let output: Val<bevy::input::mouse::MouseWheel> = <bevy::input::mouse::MouseWheel as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::mouse::MouseWheel>,
+        other: Ref<bevy::input::mouse::MouseWheel>,
+    ) {
+        let output: bool = <bevy::input::mouse::MouseWheel as std::cmp::PartialEq<
+            bevy::input::mouse::MouseWheel,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "gamepad_axis_changed_event")]
+impl bevy::input::gamepad::GamepadAxisChangedEvent {
+    fn clone(_self: Ref<bevy::input::gamepad::GamepadAxisChangedEvent>) {
+        let output: Val<bevy::input::gamepad::GamepadAxisChangedEvent> = <bevy::input::gamepad::GamepadAxisChangedEvent as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::gamepad::GamepadAxisChangedEvent>,
+        other: Ref<bevy::input::gamepad::GamepadAxisChangedEvent>,
+    ) {
+        let output: bool = <bevy::input::gamepad::GamepadAxisChangedEvent as std::cmp::PartialEq<
+            bevy::input::gamepad::GamepadAxisChangedEvent,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn new(
+        entity: Val<bevy::ecs::entity::Entity>,
+        axis: Val<bevy::input::gamepad::GamepadAxis>,
+        value: f32,
+    ) {
+        let output: Val<bevy::input::gamepad::GamepadAxisChangedEvent> = bevy::input::gamepad::GamepadAxisChangedEvent::new(
+                entity.into_inner(),
+                axis.into_inner(),
+                value,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "gamepad_button_changed_event")]
+impl bevy::input::gamepad::GamepadButtonChangedEvent {
+    fn clone(_self: Ref<bevy::input::gamepad::GamepadButtonChangedEvent>) {
+        let output: Val<bevy::input::gamepad::GamepadButtonChangedEvent> = <bevy::input::gamepad::GamepadButtonChangedEvent as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::gamepad::GamepadButtonChangedEvent>,
+        other: Ref<bevy::input::gamepad::GamepadButtonChangedEvent>,
+    ) {
+        let output: bool = <bevy::input::gamepad::GamepadButtonChangedEvent as std::cmp::PartialEq<
+            bevy::input::gamepad::GamepadButtonChangedEvent,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn new(
+        entity: Val<bevy::ecs::entity::Entity>,
+        button: Val<bevy::input::gamepad::GamepadButton>,
+        state: Val<bevy::input::ButtonState>,
+        value: f32,
+    ) {
+        let output: Val<bevy::input::gamepad::GamepadButtonChangedEvent> = bevy::input::gamepad::GamepadButtonChangedEvent::new(
+                entity.into_inner(),
+                button.into_inner(),
+                state.into_inner(),
+                value,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "gamepad_button_state_changed_event")]
+impl bevy::input::gamepad::GamepadButtonStateChangedEvent {
+    fn assert_receiver_is_total_eq(
+        _self: Ref<bevy::input::gamepad::GamepadButtonStateChangedEvent>,
+    ) {
+        let output: () = <bevy::input::gamepad::GamepadButtonStateChangedEvent as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::input::gamepad::GamepadButtonStateChangedEvent>) {
+        let output: Val<bevy::input::gamepad::GamepadButtonStateChangedEvent> = <bevy::input::gamepad::GamepadButtonStateChangedEvent as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::gamepad::GamepadButtonStateChangedEvent>,
+        other: Ref<bevy::input::gamepad::GamepadButtonStateChangedEvent>,
+    ) {
+        let output: bool = <bevy::input::gamepad::GamepadButtonStateChangedEvent as std::cmp::PartialEq<
+            bevy::input::gamepad::GamepadButtonStateChangedEvent,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn new(
+        entity: Val<bevy::ecs::entity::Entity>,
+        button: Val<bevy::input::gamepad::GamepadButton>,
+        state: Val<bevy::input::ButtonState>,
+    ) {
+        let output: Val<bevy::input::gamepad::GamepadButtonStateChangedEvent> = bevy::input::gamepad::GamepadButtonStateChangedEvent::new(
+                entity.into_inner(),
+                button.into_inner(),
+                state.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "gamepad_connection")]
+impl bevy::input::gamepad::GamepadConnection {
+    fn clone(_self: Ref<bevy::input::gamepad::GamepadConnection>) {
+        let output: Val<bevy::input::gamepad::GamepadConnection> = <bevy::input::gamepad::GamepadConnection as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::gamepad::GamepadConnection>,
+        other: Ref<bevy::input::gamepad::GamepadConnection>,
+    ) {
+        let output: bool = <bevy::input::gamepad::GamepadConnection as std::cmp::PartialEq<
+            bevy::input::gamepad::GamepadConnection,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "gamepad_connection_event")]
+impl bevy::input::gamepad::GamepadConnectionEvent {
+    fn clone(_self: Ref<bevy::input::gamepad::GamepadConnectionEvent>) {
+        let output: Val<bevy::input::gamepad::GamepadConnectionEvent> = <bevy::input::gamepad::GamepadConnectionEvent as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn connected(_self: Ref<bevy::input::gamepad::GamepadConnectionEvent>) {
+        let output: bool = bevy::input::gamepad::GamepadConnectionEvent::connected(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn disconnected(_self: Ref<bevy::input::gamepad::GamepadConnectionEvent>) {
+        let output: bool = bevy::input::gamepad::GamepadConnectionEvent::disconnected(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::gamepad::GamepadConnectionEvent>,
+        other: Ref<bevy::input::gamepad::GamepadConnectionEvent>,
+    ) {
+        let output: bool = <bevy::input::gamepad::GamepadConnectionEvent as std::cmp::PartialEq<
+            bevy::input::gamepad::GamepadConnectionEvent,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn new(
+        gamepad: Val<bevy::ecs::entity::Entity>,
+        connection: Val<bevy::input::gamepad::GamepadConnection>,
+    ) {
+        let output: Val<bevy::input::gamepad::GamepadConnectionEvent> = bevy::input::gamepad::GamepadConnectionEvent::new(
+                gamepad.into_inner(),
+                connection.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "gamepad_event")]
+impl bevy::input::gamepad::GamepadEvent {
+    fn clone(_self: Ref<bevy::input::gamepad::GamepadEvent>) {
+        let output: Val<bevy::input::gamepad::GamepadEvent> = <bevy::input::gamepad::GamepadEvent as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::gamepad::GamepadEvent>,
+        other: Ref<bevy::input::gamepad::GamepadEvent>,
+    ) {
+        let output: bool = <bevy::input::gamepad::GamepadEvent as std::cmp::PartialEq<
+            bevy::input::gamepad::GamepadEvent,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "gamepad_input")]
+impl bevy::input::gamepad::GamepadInput {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::input::gamepad::GamepadInput>) {
+        let output: () = <bevy::input::gamepad::GamepadInput as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::input::gamepad::GamepadInput>) {
+        let output: Val<bevy::input::gamepad::GamepadInput> = <bevy::input::gamepad::GamepadInput as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::gamepad::GamepadInput>,
+        other: Ref<bevy::input::gamepad::GamepadInput>,
+    ) {
+        let output: bool = <bevy::input::gamepad::GamepadInput as std::cmp::PartialEq<
+            bevy::input::gamepad::GamepadInput,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "gamepad_rumble_request")]
+impl bevy::input::gamepad::GamepadRumbleRequest {
+    fn clone(_self: Ref<bevy::input::gamepad::GamepadRumbleRequest>) {
+        let output: Val<bevy::input::gamepad::GamepadRumbleRequest> = <bevy::input::gamepad::GamepadRumbleRequest as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn gamepad(_self: Ref<bevy::input::gamepad::GamepadRumbleRequest>) {
+        let output: Val<bevy::ecs::entity::Entity> = bevy::input::gamepad::GamepadRumbleRequest::gamepad(
+                &_self,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "raw_gamepad_axis_changed_event")]
+impl bevy::input::gamepad::RawGamepadAxisChangedEvent {
+    fn clone(_self: Ref<bevy::input::gamepad::RawGamepadAxisChangedEvent>) {
+        let output: Val<bevy::input::gamepad::RawGamepadAxisChangedEvent> = <bevy::input::gamepad::RawGamepadAxisChangedEvent as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::gamepad::RawGamepadAxisChangedEvent>,
+        other: Ref<bevy::input::gamepad::RawGamepadAxisChangedEvent>,
+    ) {
+        let output: bool = <bevy::input::gamepad::RawGamepadAxisChangedEvent as std::cmp::PartialEq<
+            bevy::input::gamepad::RawGamepadAxisChangedEvent,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn new(
+        gamepad: Val<bevy::ecs::entity::Entity>,
+        axis_type: Val<bevy::input::gamepad::GamepadAxis>,
+        value: f32,
+    ) {
+        let output: Val<bevy::input::gamepad::RawGamepadAxisChangedEvent> = bevy::input::gamepad::RawGamepadAxisChangedEvent::new(
+                gamepad.into_inner(),
+                axis_type.into_inner(),
+                value,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "raw_gamepad_button_changed_event")]
+impl bevy::input::gamepad::RawGamepadButtonChangedEvent {
+    fn clone(_self: Ref<bevy::input::gamepad::RawGamepadButtonChangedEvent>) {
+        let output: Val<bevy::input::gamepad::RawGamepadButtonChangedEvent> = <bevy::input::gamepad::RawGamepadButtonChangedEvent as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::gamepad::RawGamepadButtonChangedEvent>,
+        other: Ref<bevy::input::gamepad::RawGamepadButtonChangedEvent>,
+    ) {
+        let output: bool = <bevy::input::gamepad::RawGamepadButtonChangedEvent as std::cmp::PartialEq<
+            bevy::input::gamepad::RawGamepadButtonChangedEvent,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn new(
+        gamepad: Val<bevy::ecs::entity::Entity>,
+        button_type: Val<bevy::input::gamepad::GamepadButton>,
+        value: f32,
+    ) {
+        let output: Val<bevy::input::gamepad::RawGamepadButtonChangedEvent> = bevy::input::gamepad::RawGamepadButtonChangedEvent::new(
+                gamepad.into_inner(),
+                button_type.into_inner(),
+                value,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "raw_gamepad_event")]
+impl bevy::input::gamepad::RawGamepadEvent {
+    fn clone(_self: Ref<bevy::input::gamepad::RawGamepadEvent>) {
+        let output: Val<bevy::input::gamepad::RawGamepadEvent> = <bevy::input::gamepad::RawGamepadEvent as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::gamepad::RawGamepadEvent>,
+        other: Ref<bevy::input::gamepad::RawGamepadEvent>,
+    ) {
+        let output: bool = <bevy::input::gamepad::RawGamepadEvent as std::cmp::PartialEq<
+            bevy::input::gamepad::RawGamepadEvent,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "pinch_gesture")]
+impl bevy::input::gestures::PinchGesture {
+    fn clone(_self: Ref<bevy::input::gestures::PinchGesture>) {
+        let output: Val<bevy::input::gestures::PinchGesture> = <bevy::input::gestures::PinchGesture as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::gestures::PinchGesture>,
+        other: Ref<bevy::input::gestures::PinchGesture>,
+    ) {
+        let output: bool = <bevy::input::gestures::PinchGesture as std::cmp::PartialEq<
+            bevy::input::gestures::PinchGesture,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "rotation_gesture")]
+impl bevy::input::gestures::RotationGesture {
+    fn clone(_self: Ref<bevy::input::gestures::RotationGesture>) {
+        let output: Val<bevy::input::gestures::RotationGesture> = <bevy::input::gestures::RotationGesture as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::gestures::RotationGesture>,
+        other: Ref<bevy::input::gestures::RotationGesture>,
+    ) {
+        let output: bool = <bevy::input::gestures::RotationGesture as std::cmp::PartialEq<
+            bevy::input::gestures::RotationGesture,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "double_tap_gesture")]
+impl bevy::input::gestures::DoubleTapGesture {
+    fn clone(_self: Ref<bevy::input::gestures::DoubleTapGesture>) {
+        let output: Val<bevy::input::gestures::DoubleTapGesture> = <bevy::input::gestures::DoubleTapGesture as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::gestures::DoubleTapGesture>,
+        other: Ref<bevy::input::gestures::DoubleTapGesture>,
+    ) {
+        let output: bool = <bevy::input::gestures::DoubleTapGesture as std::cmp::PartialEq<
+            bevy::input::gestures::DoubleTapGesture,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "pan_gesture")]
+impl bevy::input::gestures::PanGesture {
+    fn clone(_self: Ref<bevy::input::gestures::PanGesture>) {
+        let output: Val<bevy::input::gestures::PanGesture> = <bevy::input::gestures::PanGesture as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::gestures::PanGesture>,
+        other: Ref<bevy::input::gestures::PanGesture>,
+    ) {
+        let output: bool = <bevy::input::gestures::PanGesture as std::cmp::PartialEq<
+            bevy::input::gestures::PanGesture,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "button_state")]
+impl bevy::input::ButtonState {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::input::ButtonState>) {
+        let output: () = <bevy::input::ButtonState as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::input::ButtonState>) {
+        let output: Val<bevy::input::ButtonState> = <bevy::input::ButtonState as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::input::ButtonState>, other: Ref<bevy::input::ButtonState>) {
+        let output: bool = <bevy::input::ButtonState as std::cmp::PartialEq<
+            bevy::input::ButtonState,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn is_pressed(_self: Ref<bevy::input::ButtonState>) {
+        let output: bool = bevy::input::ButtonState::is_pressed(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "button_settings")]
+impl bevy::input::gamepad::ButtonSettings {
+    fn clone(_self: Ref<bevy::input::gamepad::ButtonSettings>) {
+        let output: Val<bevy::input::gamepad::ButtonSettings> = <bevy::input::gamepad::ButtonSettings as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::gamepad::ButtonSettings>,
+        other: Ref<bevy::input::gamepad::ButtonSettings>,
+    ) {
+        let output: bool = <bevy::input::gamepad::ButtonSettings as std::cmp::PartialEq<
+            bevy::input::gamepad::ButtonSettings,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn is_pressed(_self: Ref<bevy::input::gamepad::ButtonSettings>, value: f32) {
+        let output: bool = bevy::input::gamepad::ButtonSettings::is_pressed(
+                &_self,
+                value,
+            )
+            .into();
+        output
+    }
+    fn is_released(_self: Ref<bevy::input::gamepad::ButtonSettings>, value: f32) {
+        let output: bool = bevy::input::gamepad::ButtonSettings::is_released(
+                &_self,
+                value,
+            )
+            .into();
+        output
+    }
+    fn press_threshold(_self: Ref<bevy::input::gamepad::ButtonSettings>) {
+        let output: f32 = bevy::input::gamepad::ButtonSettings::press_threshold(&_self)
+            .into();
+        output
+    }
+    fn release_threshold(_self: Ref<bevy::input::gamepad::ButtonSettings>) {
+        let output: f32 = bevy::input::gamepad::ButtonSettings::release_threshold(&_self)
+            .into();
+        output
+    }
+    fn set_press_threshold(
+        mut _self: Mut<bevy::input::gamepad::ButtonSettings>,
+        value: f32,
+    ) {
+        let output: f32 = bevy::input::gamepad::ButtonSettings::set_press_threshold(
+                &mut _self,
+                value,
+            )
+            .into();
+        output
+    }
+    fn set_release_threshold(
+        mut _self: Mut<bevy::input::gamepad::ButtonSettings>,
+        value: f32,
+    ) {
+        let output: f32 = bevy::input::gamepad::ButtonSettings::set_release_threshold(
+                &mut _self,
+                value,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "axis_settings")]
+impl bevy::input::gamepad::AxisSettings {
+    fn clamp(_self: Ref<bevy::input::gamepad::AxisSettings>, new_value: f32) {
+        let output: f32 = bevy::input::gamepad::AxisSettings::clamp(&_self, new_value)
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::input::gamepad::AxisSettings>) {
+        let output: Val<bevy::input::gamepad::AxisSettings> = <bevy::input::gamepad::AxisSettings as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn deadzone_lowerbound(_self: Ref<bevy::input::gamepad::AxisSettings>) {
+        let output: f32 = bevy::input::gamepad::AxisSettings::deadzone_lowerbound(&_self)
+            .into();
+        output
+    }
+    fn deadzone_upperbound(_self: Ref<bevy::input::gamepad::AxisSettings>) {
+        let output: f32 = bevy::input::gamepad::AxisSettings::deadzone_upperbound(&_self)
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::gamepad::AxisSettings>,
+        other: Ref<bevy::input::gamepad::AxisSettings>,
+    ) {
+        let output: bool = <bevy::input::gamepad::AxisSettings as std::cmp::PartialEq<
+            bevy::input::gamepad::AxisSettings,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn filter(
+        _self: Ref<bevy::input::gamepad::AxisSettings>,
+        new_value: f32,
+        old_value: std::option::Option<f32>,
+    ) {
+        let output: std::option::Option<f32> = bevy::input::gamepad::AxisSettings::filter(
+                &_self,
+                new_value,
+                old_value,
+            )
+            .into();
+        output
+    }
+    fn livezone_lowerbound(_self: Ref<bevy::input::gamepad::AxisSettings>) {
+        let output: f32 = bevy::input::gamepad::AxisSettings::livezone_lowerbound(&_self)
+            .into();
+        output
+    }
+    fn livezone_upperbound(_self: Ref<bevy::input::gamepad::AxisSettings>) {
+        let output: f32 = bevy::input::gamepad::AxisSettings::livezone_upperbound(&_self)
+            .into();
+        output
+    }
+    fn set_deadzone_lowerbound(
+        mut _self: Mut<bevy::input::gamepad::AxisSettings>,
+        value: f32,
+    ) {
+        let output: f32 = bevy::input::gamepad::AxisSettings::set_deadzone_lowerbound(
+                &mut _self,
+                value,
+            )
+            .into();
+        output
+    }
+    fn set_deadzone_upperbound(
+        mut _self: Mut<bevy::input::gamepad::AxisSettings>,
+        value: f32,
+    ) {
+        let output: f32 = bevy::input::gamepad::AxisSettings::set_deadzone_upperbound(
+                &mut _self,
+                value,
+            )
+            .into();
+        output
+    }
+    fn set_livezone_lowerbound(
+        mut _self: Mut<bevy::input::gamepad::AxisSettings>,
+        value: f32,
+    ) {
+        let output: f32 = bevy::input::gamepad::AxisSettings::set_livezone_lowerbound(
+                &mut _self,
+                value,
+            )
+            .into();
+        output
+    }
+    fn set_livezone_upperbound(
+        mut _self: Mut<bevy::input::gamepad::AxisSettings>,
+        value: f32,
+    ) {
+        let output: f32 = bevy::input::gamepad::AxisSettings::set_livezone_upperbound(
+                &mut _self,
+                value,
+            )
+            .into();
+        output
+    }
+    fn set_threshold(mut _self: Mut<bevy::input::gamepad::AxisSettings>, value: f32) {
+        let output: f32 = bevy::input::gamepad::AxisSettings::set_threshold(
+                &mut _self,
+                value,
+            )
+            .into();
+        output
+    }
+    fn threshold(_self: Ref<bevy::input::gamepad::AxisSettings>) {
+        let output: f32 = bevy::input::gamepad::AxisSettings::threshold(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "button_axis_settings")]
+impl bevy::input::gamepad::ButtonAxisSettings {
+    fn clone(_self: Ref<bevy::input::gamepad::ButtonAxisSettings>) {
+        let output: Val<bevy::input::gamepad::ButtonAxisSettings> = <bevy::input::gamepad::ButtonAxisSettings as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn filter(
+        _self: Ref<bevy::input::gamepad::ButtonAxisSettings>,
+        new_value: f32,
+        old_value: std::option::Option<f32>,
+    ) {
+        let output: std::option::Option<f32> = bevy::input::gamepad::ButtonAxisSettings::filter(
+                &_self,
+                new_value,
+                old_value,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "gamepad_rumble_intensity")]
+impl bevy::input::gamepad::GamepadRumbleIntensity {
+    fn clone(_self: Ref<bevy::input::gamepad::GamepadRumbleIntensity>) {
+        let output: Val<bevy::input::gamepad::GamepadRumbleIntensity> = <bevy::input::gamepad::GamepadRumbleIntensity as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::gamepad::GamepadRumbleIntensity>,
+        other: Ref<bevy::input::gamepad::GamepadRumbleIntensity>,
+    ) {
+        let output: bool = <bevy::input::gamepad::GamepadRumbleIntensity as std::cmp::PartialEq<
+            bevy::input::gamepad::GamepadRumbleIntensity,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn strong_motor(intensity: f32) {
+        let output: Val<bevy::input::gamepad::GamepadRumbleIntensity> = bevy::input::gamepad::GamepadRumbleIntensity::strong_motor(
+                intensity,
+            )
+            .into();
+        output
+    }
+    fn weak_motor(intensity: f32) {
+        let output: Val<bevy::input::gamepad::GamepadRumbleIntensity> = bevy::input::gamepad::GamepadRumbleIntensity::weak_motor(
+                intensity,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "key")]
+impl bevy::input::keyboard::Key {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::input::keyboard::Key>) {
+        let output: () = <bevy::input::keyboard::Key as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::input::keyboard::Key>) {
+        let output: Val<bevy::input::keyboard::Key> = <bevy::input::keyboard::Key as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::keyboard::Key>,
+        other: Ref<bevy::input::keyboard::Key>,
+    ) {
+        let output: bool = <bevy::input::keyboard::Key as std::cmp::PartialEq<
+            bevy::input::keyboard::Key,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "native_key_code")]
+impl bevy::input::keyboard::NativeKeyCode {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::input::keyboard::NativeKeyCode>) {
+        let output: () = <bevy::input::keyboard::NativeKeyCode as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::input::keyboard::NativeKeyCode>) {
+        let output: Val<bevy::input::keyboard::NativeKeyCode> = <bevy::input::keyboard::NativeKeyCode as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::keyboard::NativeKeyCode>,
+        other: Ref<bevy::input::keyboard::NativeKeyCode>,
+    ) {
+        let output: bool = <bevy::input::keyboard::NativeKeyCode as std::cmp::PartialEq<
+            bevy::input::keyboard::NativeKeyCode,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "native_key")]
+impl bevy::input::keyboard::NativeKey {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::input::keyboard::NativeKey>) {
+        let output: () = <bevy::input::keyboard::NativeKey as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::input::keyboard::NativeKey>) {
+        let output: Val<bevy::input::keyboard::NativeKey> = <bevy::input::keyboard::NativeKey as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::keyboard::NativeKey>,
+        other: Ref<bevy::input::keyboard::NativeKey>,
+    ) {
+        let output: bool = <bevy::input::keyboard::NativeKey as std::cmp::PartialEq<
+            bevy::input::keyboard::NativeKey,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "mouse_scroll_unit")]
+impl bevy::input::mouse::MouseScrollUnit {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::input::mouse::MouseScrollUnit>) {
+        let output: () = <bevy::input::mouse::MouseScrollUnit as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::input::mouse::MouseScrollUnit>) {
+        let output: Val<bevy::input::mouse::MouseScrollUnit> = <bevy::input::mouse::MouseScrollUnit as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::mouse::MouseScrollUnit>,
+        other: Ref<bevy::input::mouse::MouseScrollUnit>,
+    ) {
+        let output: bool = <bevy::input::mouse::MouseScrollUnit as std::cmp::PartialEq<
+            bevy::input::mouse::MouseScrollUnit,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "touch_phase")]
+impl bevy::input::touch::TouchPhase {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::input::touch::TouchPhase>) {
+        let output: () = <bevy::input::touch::TouchPhase as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::input::touch::TouchPhase>) {
+        let output: Val<bevy::input::touch::TouchPhase> = <bevy::input::touch::TouchPhase as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::touch::TouchPhase>,
+        other: Ref<bevy::input::touch::TouchPhase>,
+    ) {
+        let output: bool = <bevy::input::touch::TouchPhase as std::cmp::PartialEq<
+            bevy::input::touch::TouchPhase,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "force_touch")]
+impl bevy::input::touch::ForceTouch {
+    fn clone(_self: Ref<bevy::input::touch::ForceTouch>) {
+        let output: Val<bevy::input::touch::ForceTouch> = <bevy::input::touch::ForceTouch as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::input::touch::ForceTouch>,
+        other: Ref<bevy::input::touch::ForceTouch>,
+    ) {
+        let output: bool = <bevy::input::touch::ForceTouch as std::cmp::PartialEq<
+            bevy::input::touch::ForceTouch,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
 impl ::bevy::app::Plugin for BevyInputScriptingPlugin {
     fn build(&self, app: &mut ::bevy::prelude::App) {
         let mut world = app.world_mut();
-        NamespaceBuilder::<::bevy::input::gamepad::Gamepad>::new(world)
-            .register(
-                "dpad",
-                |_self: Ref<bevy::input::gamepad::Gamepad>| {
-                    let output: Val<bevy::math::Vec2> = bevy::input::gamepad::Gamepad::dpad(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "just_pressed",
-                |
-                    _self: Ref<bevy::input::gamepad::Gamepad>,
-                    button_type: Val<bevy::input::gamepad::GamepadButton>|
-                {
-                    let output: bool = bevy::input::gamepad::Gamepad::just_pressed(
-                            &_self,
-                            button_type.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "just_released",
-                |
-                    _self: Ref<bevy::input::gamepad::Gamepad>,
-                    button_type: Val<bevy::input::gamepad::GamepadButton>|
-                {
-                    let output: bool = bevy::input::gamepad::Gamepad::just_released(
-                            &_self,
-                            button_type.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "left_stick",
-                |_self: Ref<bevy::input::gamepad::Gamepad>| {
-                    let output: Val<bevy::math::Vec2> = bevy::input::gamepad::Gamepad::left_stick(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "pressed",
-                |
-                    _self: Ref<bevy::input::gamepad::Gamepad>,
-                    button_type: Val<bevy::input::gamepad::GamepadButton>|
-                {
-                    let output: bool = bevy::input::gamepad::Gamepad::pressed(
-                            &_self,
-                            button_type.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "product_id",
-                |_self: Ref<bevy::input::gamepad::Gamepad>| {
-                    let output: std::option::Option<u16> = bevy::input::gamepad::Gamepad::product_id(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "right_stick",
-                |_self: Ref<bevy::input::gamepad::Gamepad>| {
-                    let output: Val<bevy::math::Vec2> = bevy::input::gamepad::Gamepad::right_stick(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "vendor_id",
-                |_self: Ref<bevy::input::gamepad::Gamepad>| {
-                    let output: std::option::Option<u16> = bevy::input::gamepad::Gamepad::vendor_id(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::gamepad::GamepadAxis>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::input::gamepad::GamepadAxis>| {
-                    let output: () = <bevy::input::gamepad::GamepadAxis as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gamepad::GamepadAxis>| {
-                    let output: Val<bevy::input::gamepad::GamepadAxis> = <bevy::input::gamepad::GamepadAxis as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::gamepad::GamepadAxis>,
-                    other: Ref<bevy::input::gamepad::GamepadAxis>|
-                {
-                    let output: bool = <bevy::input::gamepad::GamepadAxis as std::cmp::PartialEq<
-                        bevy::input::gamepad::GamepadAxis,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::gamepad::GamepadButton>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::input::gamepad::GamepadButton>| {
-                    let output: () = <bevy::input::gamepad::GamepadButton as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gamepad::GamepadButton>| {
-                    let output: Val<bevy::input::gamepad::GamepadButton> = <bevy::input::gamepad::GamepadButton as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::gamepad::GamepadButton>,
-                    other: Ref<bevy::input::gamepad::GamepadButton>|
-                {
-                    let output: bool = <bevy::input::gamepad::GamepadButton as std::cmp::PartialEq<
-                        bevy::input::gamepad::GamepadButton,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::gamepad::GamepadSettings>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gamepad::GamepadSettings>| {
-                    let output: Val<bevy::input::gamepad::GamepadSettings> = <bevy::input::gamepad::GamepadSettings as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::keyboard::KeyCode>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::input::keyboard::KeyCode>| {
-                    let output: () = <bevy::input::keyboard::KeyCode as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::keyboard::KeyCode>| {
-                    let output: Val<bevy::input::keyboard::KeyCode> = <bevy::input::keyboard::KeyCode as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::keyboard::KeyCode>,
-                    other: Ref<bevy::input::keyboard::KeyCode>|
-                {
-                    let output: bool = <bevy::input::keyboard::KeyCode as std::cmp::PartialEq<
-                        bevy::input::keyboard::KeyCode,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::mouse::MouseButton>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::input::mouse::MouseButton>| {
-                    let output: () = <bevy::input::mouse::MouseButton as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::mouse::MouseButton>| {
-                    let output: Val<bevy::input::mouse::MouseButton> = <bevy::input::mouse::MouseButton as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::mouse::MouseButton>,
-                    other: Ref<bevy::input::mouse::MouseButton>|
-                {
-                    let output: bool = <bevy::input::mouse::MouseButton as std::cmp::PartialEq<
-                        bevy::input::mouse::MouseButton,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::touch::TouchInput>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::touch::TouchInput>| {
-                    let output: Val<bevy::input::touch::TouchInput> = <bevy::input::touch::TouchInput as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::touch::TouchInput>,
-                    other: Ref<bevy::input::touch::TouchInput>|
-                {
-                    let output: bool = <bevy::input::touch::TouchInput as std::cmp::PartialEq<
-                        bevy::input::touch::TouchInput,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::keyboard::KeyboardFocusLost>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::input::keyboard::KeyboardFocusLost>| {
-                    let output: () = <bevy::input::keyboard::KeyboardFocusLost as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::keyboard::KeyboardFocusLost>| {
-                    let output: Val<bevy::input::keyboard::KeyboardFocusLost> = <bevy::input::keyboard::KeyboardFocusLost as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::keyboard::KeyboardFocusLost>,
-                    other: Ref<bevy::input::keyboard::KeyboardFocusLost>|
-                {
-                    let output: bool = <bevy::input::keyboard::KeyboardFocusLost as std::cmp::PartialEq<
-                        bevy::input::keyboard::KeyboardFocusLost,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::keyboard::KeyboardInput>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::input::keyboard::KeyboardInput>| {
-                    let output: () = <bevy::input::keyboard::KeyboardInput as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::keyboard::KeyboardInput>| {
-                    let output: Val<bevy::input::keyboard::KeyboardInput> = <bevy::input::keyboard::KeyboardInput as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::keyboard::KeyboardInput>,
-                    other: Ref<bevy::input::keyboard::KeyboardInput>|
-                {
-                    let output: bool = <bevy::input::keyboard::KeyboardInput as std::cmp::PartialEq<
-                        bevy::input::keyboard::KeyboardInput,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::mouse::AccumulatedMouseMotion>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::mouse::AccumulatedMouseMotion>| {
-                    let output: Val<bevy::input::mouse::AccumulatedMouseMotion> = <bevy::input::mouse::AccumulatedMouseMotion as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::mouse::AccumulatedMouseMotion>,
-                    other: Ref<bevy::input::mouse::AccumulatedMouseMotion>|
-                {
-                    let output: bool = <bevy::input::mouse::AccumulatedMouseMotion as std::cmp::PartialEq<
-                        bevy::input::mouse::AccumulatedMouseMotion,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::mouse::AccumulatedMouseScroll>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::mouse::AccumulatedMouseScroll>| {
-                    let output: Val<bevy::input::mouse::AccumulatedMouseScroll> = <bevy::input::mouse::AccumulatedMouseScroll as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::mouse::AccumulatedMouseScroll>,
-                    other: Ref<bevy::input::mouse::AccumulatedMouseScroll>|
-                {
-                    let output: bool = <bevy::input::mouse::AccumulatedMouseScroll as std::cmp::PartialEq<
-                        bevy::input::mouse::AccumulatedMouseScroll,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::mouse::MouseButtonInput>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::input::mouse::MouseButtonInput>| {
-                    let output: () = <bevy::input::mouse::MouseButtonInput as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::mouse::MouseButtonInput>| {
-                    let output: Val<bevy::input::mouse::MouseButtonInput> = <bevy::input::mouse::MouseButtonInput as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::mouse::MouseButtonInput>,
-                    other: Ref<bevy::input::mouse::MouseButtonInput>|
-                {
-                    let output: bool = <bevy::input::mouse::MouseButtonInput as std::cmp::PartialEq<
-                        bevy::input::mouse::MouseButtonInput,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::mouse::MouseMotion>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::mouse::MouseMotion>| {
-                    let output: Val<bevy::input::mouse::MouseMotion> = <bevy::input::mouse::MouseMotion as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::mouse::MouseMotion>,
-                    other: Ref<bevy::input::mouse::MouseMotion>|
-                {
-                    let output: bool = <bevy::input::mouse::MouseMotion as std::cmp::PartialEq<
-                        bevy::input::mouse::MouseMotion,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::mouse::MouseWheel>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::mouse::MouseWheel>| {
-                    let output: Val<bevy::input::mouse::MouseWheel> = <bevy::input::mouse::MouseWheel as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::mouse::MouseWheel>,
-                    other: Ref<bevy::input::mouse::MouseWheel>|
-                {
-                    let output: bool = <bevy::input::mouse::MouseWheel as std::cmp::PartialEq<
-                        bevy::input::mouse::MouseWheel,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::gamepad::GamepadAxisChangedEvent>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gamepad::GamepadAxisChangedEvent>| {
-                    let output: Val<bevy::input::gamepad::GamepadAxisChangedEvent> = <bevy::input::gamepad::GamepadAxisChangedEvent as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::gamepad::GamepadAxisChangedEvent>,
-                    other: Ref<bevy::input::gamepad::GamepadAxisChangedEvent>|
-                {
-                    let output: bool = <bevy::input::gamepad::GamepadAxisChangedEvent as std::cmp::PartialEq<
-                        bevy::input::gamepad::GamepadAxisChangedEvent,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |
-                    entity: Val<bevy::ecs::entity::Entity>,
-                    axis: Val<bevy::input::gamepad::GamepadAxis>,
-                    value: f32|
-                {
-                    let output: Val<bevy::input::gamepad::GamepadAxisChangedEvent> = bevy::input::gamepad::GamepadAxisChangedEvent::new(
-                            entity.into_inner(),
-                            axis.into_inner(),
-                            value,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::gamepad::GamepadButtonChangedEvent>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gamepad::GamepadButtonChangedEvent>| {
-                    let output: Val<bevy::input::gamepad::GamepadButtonChangedEvent> = <bevy::input::gamepad::GamepadButtonChangedEvent as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::gamepad::GamepadButtonChangedEvent>,
-                    other: Ref<bevy::input::gamepad::GamepadButtonChangedEvent>|
-                {
-                    let output: bool = <bevy::input::gamepad::GamepadButtonChangedEvent as std::cmp::PartialEq<
-                        bevy::input::gamepad::GamepadButtonChangedEvent,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |
-                    entity: Val<bevy::ecs::entity::Entity>,
-                    button: Val<bevy::input::gamepad::GamepadButton>,
-                    state: Val<bevy::input::ButtonState>,
-                    value: f32|
-                {
-                    let output: Val<bevy::input::gamepad::GamepadButtonChangedEvent> = bevy::input::gamepad::GamepadButtonChangedEvent::new(
-                            entity.into_inner(),
-                            button.into_inner(),
-                            state.into_inner(),
-                            value,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<
-            ::bevy::input::gamepad::GamepadButtonStateChangedEvent,
-        >::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::input::gamepad::GamepadButtonStateChangedEvent>| {
-                    let output: () = <bevy::input::gamepad::GamepadButtonStateChangedEvent as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gamepad::GamepadButtonStateChangedEvent>| {
-                    let output: Val<
-                        bevy::input::gamepad::GamepadButtonStateChangedEvent,
-                    > = <bevy::input::gamepad::GamepadButtonStateChangedEvent as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::gamepad::GamepadButtonStateChangedEvent>,
-                    other: Ref<bevy::input::gamepad::GamepadButtonStateChangedEvent>|
-                {
-                    let output: bool = <bevy::input::gamepad::GamepadButtonStateChangedEvent as std::cmp::PartialEq<
-                        bevy::input::gamepad::GamepadButtonStateChangedEvent,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |
-                    entity: Val<bevy::ecs::entity::Entity>,
-                    button: Val<bevy::input::gamepad::GamepadButton>,
-                    state: Val<bevy::input::ButtonState>|
-                {
-                    let output: Val<
-                        bevy::input::gamepad::GamepadButtonStateChangedEvent,
-                    > = bevy::input::gamepad::GamepadButtonStateChangedEvent::new(
-                            entity.into_inner(),
-                            button.into_inner(),
-                            state.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::gamepad::GamepadConnection>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gamepad::GamepadConnection>| {
-                    let output: Val<bevy::input::gamepad::GamepadConnection> = <bevy::input::gamepad::GamepadConnection as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::gamepad::GamepadConnection>,
-                    other: Ref<bevy::input::gamepad::GamepadConnection>|
-                {
-                    let output: bool = <bevy::input::gamepad::GamepadConnection as std::cmp::PartialEq<
-                        bevy::input::gamepad::GamepadConnection,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::gamepad::GamepadConnectionEvent>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gamepad::GamepadConnectionEvent>| {
-                    let output: Val<bevy::input::gamepad::GamepadConnectionEvent> = <bevy::input::gamepad::GamepadConnectionEvent as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "connected",
-                |_self: Ref<bevy::input::gamepad::GamepadConnectionEvent>| {
-                    let output: bool = bevy::input::gamepad::GamepadConnectionEvent::connected(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "disconnected",
-                |_self: Ref<bevy::input::gamepad::GamepadConnectionEvent>| {
-                    let output: bool = bevy::input::gamepad::GamepadConnectionEvent::disconnected(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::gamepad::GamepadConnectionEvent>,
-                    other: Ref<bevy::input::gamepad::GamepadConnectionEvent>|
-                {
-                    let output: bool = <bevy::input::gamepad::GamepadConnectionEvent as std::cmp::PartialEq<
-                        bevy::input::gamepad::GamepadConnectionEvent,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |
-                    gamepad: Val<bevy::ecs::entity::Entity>,
-                    connection: Val<bevy::input::gamepad::GamepadConnection>|
-                {
-                    let output: Val<bevy::input::gamepad::GamepadConnectionEvent> = bevy::input::gamepad::GamepadConnectionEvent::new(
-                            gamepad.into_inner(),
-                            connection.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::gamepad::GamepadEvent>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gamepad::GamepadEvent>| {
-                    let output: Val<bevy::input::gamepad::GamepadEvent> = <bevy::input::gamepad::GamepadEvent as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::gamepad::GamepadEvent>,
-                    other: Ref<bevy::input::gamepad::GamepadEvent>|
-                {
-                    let output: bool = <bevy::input::gamepad::GamepadEvent as std::cmp::PartialEq<
-                        bevy::input::gamepad::GamepadEvent,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::gamepad::GamepadInput>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::input::gamepad::GamepadInput>| {
-                    let output: () = <bevy::input::gamepad::GamepadInput as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gamepad::GamepadInput>| {
-                    let output: Val<bevy::input::gamepad::GamepadInput> = <bevy::input::gamepad::GamepadInput as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::gamepad::GamepadInput>,
-                    other: Ref<bevy::input::gamepad::GamepadInput>|
-                {
-                    let output: bool = <bevy::input::gamepad::GamepadInput as std::cmp::PartialEq<
-                        bevy::input::gamepad::GamepadInput,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::gamepad::GamepadRumbleRequest>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gamepad::GamepadRumbleRequest>| {
-                    let output: Val<bevy::input::gamepad::GamepadRumbleRequest> = <bevy::input::gamepad::GamepadRumbleRequest as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "gamepad",
-                |_self: Ref<bevy::input::gamepad::GamepadRumbleRequest>| {
-                    let output: Val<bevy::ecs::entity::Entity> = bevy::input::gamepad::GamepadRumbleRequest::gamepad(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<
-            ::bevy::input::gamepad::RawGamepadAxisChangedEvent,
-        >::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gamepad::RawGamepadAxisChangedEvent>| {
-                    let output: Val<bevy::input::gamepad::RawGamepadAxisChangedEvent> = <bevy::input::gamepad::RawGamepadAxisChangedEvent as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::gamepad::RawGamepadAxisChangedEvent>,
-                    other: Ref<bevy::input::gamepad::RawGamepadAxisChangedEvent>|
-                {
-                    let output: bool = <bevy::input::gamepad::RawGamepadAxisChangedEvent as std::cmp::PartialEq<
-                        bevy::input::gamepad::RawGamepadAxisChangedEvent,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |
-                    gamepad: Val<bevy::ecs::entity::Entity>,
-                    axis_type: Val<bevy::input::gamepad::GamepadAxis>,
-                    value: f32|
-                {
-                    let output: Val<bevy::input::gamepad::RawGamepadAxisChangedEvent> = bevy::input::gamepad::RawGamepadAxisChangedEvent::new(
-                            gamepad.into_inner(),
-                            axis_type.into_inner(),
-                            value,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<
-            ::bevy::input::gamepad::RawGamepadButtonChangedEvent,
-        >::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gamepad::RawGamepadButtonChangedEvent>| {
-                    let output: Val<
-                        bevy::input::gamepad::RawGamepadButtonChangedEvent,
-                    > = <bevy::input::gamepad::RawGamepadButtonChangedEvent as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::gamepad::RawGamepadButtonChangedEvent>,
-                    other: Ref<bevy::input::gamepad::RawGamepadButtonChangedEvent>|
-                {
-                    let output: bool = <bevy::input::gamepad::RawGamepadButtonChangedEvent as std::cmp::PartialEq<
-                        bevy::input::gamepad::RawGamepadButtonChangedEvent,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |
-                    gamepad: Val<bevy::ecs::entity::Entity>,
-                    button_type: Val<bevy::input::gamepad::GamepadButton>,
-                    value: f32|
-                {
-                    let output: Val<
-                        bevy::input::gamepad::RawGamepadButtonChangedEvent,
-                    > = bevy::input::gamepad::RawGamepadButtonChangedEvent::new(
-                            gamepad.into_inner(),
-                            button_type.into_inner(),
-                            value,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::gamepad::RawGamepadEvent>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gamepad::RawGamepadEvent>| {
-                    let output: Val<bevy::input::gamepad::RawGamepadEvent> = <bevy::input::gamepad::RawGamepadEvent as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::gamepad::RawGamepadEvent>,
-                    other: Ref<bevy::input::gamepad::RawGamepadEvent>|
-                {
-                    let output: bool = <bevy::input::gamepad::RawGamepadEvent as std::cmp::PartialEq<
-                        bevy::input::gamepad::RawGamepadEvent,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::gestures::PinchGesture>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gestures::PinchGesture>| {
-                    let output: Val<bevy::input::gestures::PinchGesture> = <bevy::input::gestures::PinchGesture as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::gestures::PinchGesture>,
-                    other: Ref<bevy::input::gestures::PinchGesture>|
-                {
-                    let output: bool = <bevy::input::gestures::PinchGesture as std::cmp::PartialEq<
-                        bevy::input::gestures::PinchGesture,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::gestures::RotationGesture>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gestures::RotationGesture>| {
-                    let output: Val<bevy::input::gestures::RotationGesture> = <bevy::input::gestures::RotationGesture as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::gestures::RotationGesture>,
-                    other: Ref<bevy::input::gestures::RotationGesture>|
-                {
-                    let output: bool = <bevy::input::gestures::RotationGesture as std::cmp::PartialEq<
-                        bevy::input::gestures::RotationGesture,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::gestures::DoubleTapGesture>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gestures::DoubleTapGesture>| {
-                    let output: Val<bevy::input::gestures::DoubleTapGesture> = <bevy::input::gestures::DoubleTapGesture as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::gestures::DoubleTapGesture>,
-                    other: Ref<bevy::input::gestures::DoubleTapGesture>|
-                {
-                    let output: bool = <bevy::input::gestures::DoubleTapGesture as std::cmp::PartialEq<
-                        bevy::input::gestures::DoubleTapGesture,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::gestures::PanGesture>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gestures::PanGesture>| {
-                    let output: Val<bevy::input::gestures::PanGesture> = <bevy::input::gestures::PanGesture as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::gestures::PanGesture>,
-                    other: Ref<bevy::input::gestures::PanGesture>|
-                {
-                    let output: bool = <bevy::input::gestures::PanGesture as std::cmp::PartialEq<
-                        bevy::input::gestures::PanGesture,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::ButtonState>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::input::ButtonState>| {
-                    let output: () = <bevy::input::ButtonState as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::ButtonState>| {
-                    let output: Val<bevy::input::ButtonState> = <bevy::input::ButtonState as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::ButtonState>,
-                    other: Ref<bevy::input::ButtonState>|
-                {
-                    let output: bool = <bevy::input::ButtonState as std::cmp::PartialEq<
-                        bevy::input::ButtonState,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_pressed",
-                |_self: Ref<bevy::input::ButtonState>| {
-                    let output: bool = bevy::input::ButtonState::is_pressed(&_self)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::gamepad::ButtonSettings>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gamepad::ButtonSettings>| {
-                    let output: Val<bevy::input::gamepad::ButtonSettings> = <bevy::input::gamepad::ButtonSettings as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::gamepad::ButtonSettings>,
-                    other: Ref<bevy::input::gamepad::ButtonSettings>|
-                {
-                    let output: bool = <bevy::input::gamepad::ButtonSettings as std::cmp::PartialEq<
-                        bevy::input::gamepad::ButtonSettings,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_pressed",
-                |_self: Ref<bevy::input::gamepad::ButtonSettings>, value: f32| {
-                    let output: bool = bevy::input::gamepad::ButtonSettings::is_pressed(
-                            &_self,
-                            value,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_released",
-                |_self: Ref<bevy::input::gamepad::ButtonSettings>, value: f32| {
-                    let output: bool = bevy::input::gamepad::ButtonSettings::is_released(
-                            &_self,
-                            value,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "press_threshold",
-                |_self: Ref<bevy::input::gamepad::ButtonSettings>| {
-                    let output: f32 = bevy::input::gamepad::ButtonSettings::press_threshold(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "release_threshold",
-                |_self: Ref<bevy::input::gamepad::ButtonSettings>| {
-                    let output: f32 = bevy::input::gamepad::ButtonSettings::release_threshold(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "set_press_threshold",
-                |mut _self: Mut<bevy::input::gamepad::ButtonSettings>, value: f32| {
-                    let output: f32 = bevy::input::gamepad::ButtonSettings::set_press_threshold(
-                            &mut _self,
-                            value,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "set_release_threshold",
-                |mut _self: Mut<bevy::input::gamepad::ButtonSettings>, value: f32| {
-                    let output: f32 = bevy::input::gamepad::ButtonSettings::set_release_threshold(
-                            &mut _self,
-                            value,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::gamepad::AxisSettings>::new(world)
-            .register(
-                "clamp",
-                |_self: Ref<bevy::input::gamepad::AxisSettings>, new_value: f32| {
-                    let output: f32 = bevy::input::gamepad::AxisSettings::clamp(
-                            &_self,
-                            new_value,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gamepad::AxisSettings>| {
-                    let output: Val<bevy::input::gamepad::AxisSettings> = <bevy::input::gamepad::AxisSettings as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "deadzone_lowerbound",
-                |_self: Ref<bevy::input::gamepad::AxisSettings>| {
-                    let output: f32 = bevy::input::gamepad::AxisSettings::deadzone_lowerbound(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "deadzone_upperbound",
-                |_self: Ref<bevy::input::gamepad::AxisSettings>| {
-                    let output: f32 = bevy::input::gamepad::AxisSettings::deadzone_upperbound(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::gamepad::AxisSettings>,
-                    other: Ref<bevy::input::gamepad::AxisSettings>|
-                {
-                    let output: bool = <bevy::input::gamepad::AxisSettings as std::cmp::PartialEq<
-                        bevy::input::gamepad::AxisSettings,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "filter",
-                |
-                    _self: Ref<bevy::input::gamepad::AxisSettings>,
-                    new_value: f32,
-                    old_value: std::option::Option<f32>|
-                {
-                    let output: std::option::Option<f32> = bevy::input::gamepad::AxisSettings::filter(
-                            &_self,
-                            new_value,
-                            old_value,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "livezone_lowerbound",
-                |_self: Ref<bevy::input::gamepad::AxisSettings>| {
-                    let output: f32 = bevy::input::gamepad::AxisSettings::livezone_lowerbound(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "livezone_upperbound",
-                |_self: Ref<bevy::input::gamepad::AxisSettings>| {
-                    let output: f32 = bevy::input::gamepad::AxisSettings::livezone_upperbound(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "set_deadzone_lowerbound",
-                |mut _self: Mut<bevy::input::gamepad::AxisSettings>, value: f32| {
-                    let output: f32 = bevy::input::gamepad::AxisSettings::set_deadzone_lowerbound(
-                            &mut _self,
-                            value,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "set_deadzone_upperbound",
-                |mut _self: Mut<bevy::input::gamepad::AxisSettings>, value: f32| {
-                    let output: f32 = bevy::input::gamepad::AxisSettings::set_deadzone_upperbound(
-                            &mut _self,
-                            value,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "set_livezone_lowerbound",
-                |mut _self: Mut<bevy::input::gamepad::AxisSettings>, value: f32| {
-                    let output: f32 = bevy::input::gamepad::AxisSettings::set_livezone_lowerbound(
-                            &mut _self,
-                            value,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "set_livezone_upperbound",
-                |mut _self: Mut<bevy::input::gamepad::AxisSettings>, value: f32| {
-                    let output: f32 = bevy::input::gamepad::AxisSettings::set_livezone_upperbound(
-                            &mut _self,
-                            value,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "set_threshold",
-                |mut _self: Mut<bevy::input::gamepad::AxisSettings>, value: f32| {
-                    let output: f32 = bevy::input::gamepad::AxisSettings::set_threshold(
-                            &mut _self,
-                            value,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "threshold",
-                |_self: Ref<bevy::input::gamepad::AxisSettings>| {
-                    let output: f32 = bevy::input::gamepad::AxisSettings::threshold(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::gamepad::ButtonAxisSettings>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gamepad::ButtonAxisSettings>| {
-                    let output: Val<bevy::input::gamepad::ButtonAxisSettings> = <bevy::input::gamepad::ButtonAxisSettings as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "filter",
-                |
-                    _self: Ref<bevy::input::gamepad::ButtonAxisSettings>,
-                    new_value: f32,
-                    old_value: std::option::Option<f32>|
-                {
-                    let output: std::option::Option<f32> = bevy::input::gamepad::ButtonAxisSettings::filter(
-                            &_self,
-                            new_value,
-                            old_value,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::gamepad::GamepadRumbleIntensity>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::gamepad::GamepadRumbleIntensity>| {
-                    let output: Val<bevy::input::gamepad::GamepadRumbleIntensity> = <bevy::input::gamepad::GamepadRumbleIntensity as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::gamepad::GamepadRumbleIntensity>,
-                    other: Ref<bevy::input::gamepad::GamepadRumbleIntensity>|
-                {
-                    let output: bool = <bevy::input::gamepad::GamepadRumbleIntensity as std::cmp::PartialEq<
-                        bevy::input::gamepad::GamepadRumbleIntensity,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "strong_motor",
-                |intensity: f32| {
-                    let output: Val<bevy::input::gamepad::GamepadRumbleIntensity> = bevy::input::gamepad::GamepadRumbleIntensity::strong_motor(
-                            intensity,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "weak_motor",
-                |intensity: f32| {
-                    let output: Val<bevy::input::gamepad::GamepadRumbleIntensity> = bevy::input::gamepad::GamepadRumbleIntensity::weak_motor(
-                            intensity,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::keyboard::Key>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::input::keyboard::Key>| {
-                    let output: () = <bevy::input::keyboard::Key as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::keyboard::Key>| {
-                    let output: Val<bevy::input::keyboard::Key> = <bevy::input::keyboard::Key as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::keyboard::Key>,
-                    other: Ref<bevy::input::keyboard::Key>|
-                {
-                    let output: bool = <bevy::input::keyboard::Key as std::cmp::PartialEq<
-                        bevy::input::keyboard::Key,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::keyboard::NativeKeyCode>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::input::keyboard::NativeKeyCode>| {
-                    let output: () = <bevy::input::keyboard::NativeKeyCode as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::keyboard::NativeKeyCode>| {
-                    let output: Val<bevy::input::keyboard::NativeKeyCode> = <bevy::input::keyboard::NativeKeyCode as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::keyboard::NativeKeyCode>,
-                    other: Ref<bevy::input::keyboard::NativeKeyCode>|
-                {
-                    let output: bool = <bevy::input::keyboard::NativeKeyCode as std::cmp::PartialEq<
-                        bevy::input::keyboard::NativeKeyCode,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::keyboard::NativeKey>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::input::keyboard::NativeKey>| {
-                    let output: () = <bevy::input::keyboard::NativeKey as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::keyboard::NativeKey>| {
-                    let output: Val<bevy::input::keyboard::NativeKey> = <bevy::input::keyboard::NativeKey as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::keyboard::NativeKey>,
-                    other: Ref<bevy::input::keyboard::NativeKey>|
-                {
-                    let output: bool = <bevy::input::keyboard::NativeKey as std::cmp::PartialEq<
-                        bevy::input::keyboard::NativeKey,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::mouse::MouseScrollUnit>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::input::mouse::MouseScrollUnit>| {
-                    let output: () = <bevy::input::mouse::MouseScrollUnit as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::mouse::MouseScrollUnit>| {
-                    let output: Val<bevy::input::mouse::MouseScrollUnit> = <bevy::input::mouse::MouseScrollUnit as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::mouse::MouseScrollUnit>,
-                    other: Ref<bevy::input::mouse::MouseScrollUnit>|
-                {
-                    let output: bool = <bevy::input::mouse::MouseScrollUnit as std::cmp::PartialEq<
-                        bevy::input::mouse::MouseScrollUnit,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::touch::TouchPhase>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::input::touch::TouchPhase>| {
-                    let output: () = <bevy::input::touch::TouchPhase as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::touch::TouchPhase>| {
-                    let output: Val<bevy::input::touch::TouchPhase> = <bevy::input::touch::TouchPhase as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::touch::TouchPhase>,
-                    other: Ref<bevy::input::touch::TouchPhase>|
-                {
-                    let output: bool = <bevy::input::touch::TouchPhase as std::cmp::PartialEq<
-                        bevy::input::touch::TouchPhase,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::input::touch::ForceTouch>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::input::touch::ForceTouch>| {
-                    let output: Val<bevy::input::touch::ForceTouch> = <bevy::input::touch::ForceTouch as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::input::touch::ForceTouch>,
-                    other: Ref<bevy::input::touch::ForceTouch>|
-                {
-                    let output: bool = <bevy::input::touch::ForceTouch as std::cmp::PartialEq<
-                        bevy::input::touch::ForceTouch,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
+        register_gamepad(&mut world);
+        register_gamepad_axis(&mut world);
+        register_gamepad_button(&mut world);
+        register_gamepad_settings(&mut world);
+        register_key_code(&mut world);
+        register_mouse_button(&mut world);
+        register_touch_input(&mut world);
+        register_keyboard_focus_lost(&mut world);
+        register_keyboard_input(&mut world);
+        register_accumulated_mouse_motion(&mut world);
+        register_accumulated_mouse_scroll(&mut world);
+        register_mouse_button_input(&mut world);
+        register_mouse_motion(&mut world);
+        register_mouse_wheel(&mut world);
+        register_gamepad_axis_changed_event(&mut world);
+        register_gamepad_button_changed_event(&mut world);
+        register_gamepad_button_state_changed_event(&mut world);
+        register_gamepad_connection(&mut world);
+        register_gamepad_connection_event(&mut world);
+        register_gamepad_event(&mut world);
+        register_gamepad_input(&mut world);
+        register_gamepad_rumble_request(&mut world);
+        register_raw_gamepad_axis_changed_event(&mut world);
+        register_raw_gamepad_button_changed_event(&mut world);
+        register_raw_gamepad_event(&mut world);
+        register_pinch_gesture(&mut world);
+        register_rotation_gesture(&mut world);
+        register_double_tap_gesture(&mut world);
+        register_pan_gesture(&mut world);
+        register_button_state(&mut world);
+        register_button_settings(&mut world);
+        register_axis_settings(&mut world);
+        register_button_axis_settings(&mut world);
+        register_gamepad_rumble_intensity(&mut world);
+        register_key(&mut world);
+        register_native_key_code(&mut world);
+        register_native_key(&mut world);
+        register_mouse_scroll_unit(&mut world);
+        register_touch_phase(&mut world);
+        register_force_touch(&mut world);
     }
 }
diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_math.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_math.rs
index 0a6ef265da..23c55f007a 100644
--- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_math.rs
+++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_math.rs
@@ -9,4539 +9,3307 @@ use bevy_mod_scripting_core::bindings::{
         namespace::NamespaceBuilder,
     },
 };
+use bevy_mod_scripting_derive::script_bindings;
 use crate::*;
 pub struct BevyMathScriptingPlugin;
+#[script_bindings(remote, name = "aspect_ratio")]
+impl bevy::math::AspectRatio {
+    fn clone(_self: Ref<bevy::math::AspectRatio>) {
+        let output: Val<bevy::math::AspectRatio> = <bevy::math::AspectRatio as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::AspectRatio>, other: Ref<bevy::math::AspectRatio>) {
+        let output: bool = <bevy::math::AspectRatio as std::cmp::PartialEq<
+            bevy::math::AspectRatio,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn inverse(_self: Ref<bevy::math::AspectRatio>) {
+        let output: Val<bevy::math::AspectRatio> = bevy::math::AspectRatio::inverse(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn is_landscape(_self: Ref<bevy::math::AspectRatio>) {
+        let output: bool = bevy::math::AspectRatio::is_landscape(&_self).into();
+        output
+    }
+    fn is_portrait(_self: Ref<bevy::math::AspectRatio>) {
+        let output: bool = bevy::math::AspectRatio::is_portrait(&_self).into();
+        output
+    }
+    fn is_square(_self: Ref<bevy::math::AspectRatio>) {
+        let output: bool = bevy::math::AspectRatio::is_square(&_self).into();
+        output
+    }
+    fn ratio(_self: Ref<bevy::math::AspectRatio>) {
+        let output: f32 = bevy::math::AspectRatio::ratio(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "compass_octant")]
+impl bevy::math::CompassOctant {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::CompassOctant>) {
+        let output: () = <bevy::math::CompassOctant as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::CompassOctant>) {
+        let output: Val<bevy::math::CompassOctant> = <bevy::math::CompassOctant as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::CompassOctant>, other: Ref<bevy::math::CompassOctant>) {
+        let output: bool = <bevy::math::CompassOctant as std::cmp::PartialEq<
+            bevy::math::CompassOctant,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "compass_quadrant")]
+impl bevy::math::CompassQuadrant {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::CompassQuadrant>) {
+        let output: () = <bevy::math::CompassQuadrant as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::CompassQuadrant>) {
+        let output: Val<bevy::math::CompassQuadrant> = <bevy::math::CompassQuadrant as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::CompassQuadrant>,
+        other: Ref<bevy::math::CompassQuadrant>,
+    ) {
+        let output: bool = <bevy::math::CompassQuadrant as std::cmp::PartialEq<
+            bevy::math::CompassQuadrant,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "isometry_2_d")]
+impl bevy::math::Isometry2d {
+    fn clone(_self: Ref<bevy::math::Isometry2d>) {
+        let output: Val<bevy::math::Isometry2d> = <bevy::math::Isometry2d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::Isometry2d>, other: Ref<bevy::math::Isometry2d>) {
+        let output: bool = <bevy::math::Isometry2d as std::cmp::PartialEq<
+            bevy::math::Isometry2d,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_rotation(rotation: Val<bevy::math::Rot2>) {
+        let output: Val<bevy::math::Isometry2d> = bevy::math::Isometry2d::from_rotation(
+                rotation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_translation(translation: Val<bevy::math::prelude::Vec2>) {
+        let output: Val<bevy::math::Isometry2d> = bevy::math::Isometry2d::from_translation(
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_xy(x: f32, y: f32) {
+        let output: Val<bevy::math::Isometry2d> = bevy::math::Isometry2d::from_xy(x, y)
+            .into();
+        output
+    }
+    fn inverse(_self: Ref<bevy::math::Isometry2d>) {
+        let output: Val<bevy::math::Isometry2d> = bevy::math::Isometry2d::inverse(&_self)
+            .into();
+        output
+    }
+    fn inverse_mul(
+        _self: Ref<bevy::math::Isometry2d>,
+        rhs: Val<bevy::math::Isometry2d>,
+    ) {
+        let output: Val<bevy::math::Isometry2d> = bevy::math::Isometry2d::inverse_mul(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn inverse_transform_point(
+        _self: Ref<bevy::math::Isometry2d>,
+        point: Val<bevy::math::prelude::Vec2>,
+    ) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::Isometry2d::inverse_transform_point(
+                &_self,
+                point.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Isometry2d>, rhs: Val<bevy::math::Isometry2d>) {
+        let output: Val<bevy::math::Isometry2d> = <bevy::math::Isometry2d as std::ops::Mul<
+            bevy::math::Isometry2d,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Isometry2d>, rhs: Val<bevy::math::prelude::Dir2>) {
+        let output: Val<bevy::math::prelude::Dir2> = <bevy::math::Isometry2d as std::ops::Mul<
+            bevy::math::prelude::Dir2,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Isometry2d>, rhs: Val<bevy::math::prelude::Vec2>) {
+        let output: Val<bevy::math::prelude::Vec2> = <bevy::math::Isometry2d as std::ops::Mul<
+            bevy::math::prelude::Vec2,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn new(
+        translation: Val<bevy::math::prelude::Vec2>,
+        rotation: Val<bevy::math::Rot2>,
+    ) {
+        let output: Val<bevy::math::Isometry2d> = bevy::math::Isometry2d::new(
+                translation.into_inner(),
+                rotation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transform_point(
+        _self: Ref<bevy::math::Isometry2d>,
+        point: Val<bevy::math::prelude::Vec2>,
+    ) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::Isometry2d::transform_point(
+                &_self,
+                point.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "isometry_3_d")]
+impl bevy::math::Isometry3d {
+    fn clone(_self: Ref<bevy::math::Isometry3d>) {
+        let output: Val<bevy::math::Isometry3d> = <bevy::math::Isometry3d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::Isometry3d>, other: Ref<bevy::math::Isometry3d>) {
+        let output: bool = <bevy::math::Isometry3d as std::cmp::PartialEq<
+            bevy::math::Isometry3d,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_rotation(rotation: Val<bevy::math::prelude::Quat>) {
+        let output: Val<bevy::math::Isometry3d> = bevy::math::Isometry3d::from_rotation(
+                rotation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_xyz(x: f32, y: f32, z: f32) {
+        let output: Val<bevy::math::Isometry3d> = bevy::math::Isometry3d::from_xyz(
+                x,
+                y,
+                z,
+            )
+            .into();
+        output
+    }
+    fn inverse(_self: Ref<bevy::math::Isometry3d>) {
+        let output: Val<bevy::math::Isometry3d> = bevy::math::Isometry3d::inverse(&_self)
+            .into();
+        output
+    }
+    fn inverse_mul(
+        _self: Ref<bevy::math::Isometry3d>,
+        rhs: Val<bevy::math::Isometry3d>,
+    ) {
+        let output: Val<bevy::math::Isometry3d> = bevy::math::Isometry3d::inverse_mul(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Isometry3d>, rhs: Val<bevy::math::Isometry3d>) {
+        let output: Val<bevy::math::Isometry3d> = <bevy::math::Isometry3d as std::ops::Mul<
+            bevy::math::Isometry3d,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Isometry3d>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Isometry3d as std::ops::Mul<
+            bevy::math::Vec3A,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Isometry3d>, rhs: Val<bevy::math::prelude::Dir3>) {
+        let output: Val<bevy::math::prelude::Dir3> = <bevy::math::Isometry3d as std::ops::Mul<
+            bevy::math::prelude::Dir3,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Isometry3d>, rhs: Val<bevy::math::prelude::Vec3>) {
+        let output: Val<bevy::math::prelude::Vec3> = <bevy::math::Isometry3d as std::ops::Mul<
+            bevy::math::prelude::Vec3,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "ray_2_d")]
+impl bevy::math::Ray2d {
+    fn clone(_self: Ref<bevy::math::Ray2d>) {
+        let output: Val<bevy::math::Ray2d> = <bevy::math::Ray2d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::Ray2d>, other: Ref<bevy::math::Ray2d>) {
+        let output: bool = <bevy::math::Ray2d as std::cmp::PartialEq<
+            bevy::math::Ray2d,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn get_point(_self: Ref<bevy::math::Ray2d>, distance: f32) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::Ray2d::get_point(
+                &_self,
+                distance,
+            )
+            .into();
+        output
+    }
+    fn intersect_plane(
+        _self: Ref<bevy::math::Ray2d>,
+        plane_origin: Val<bevy::math::prelude::Vec2>,
+        plane: Val<bevy::math::primitives::Plane2d>,
+    ) {
+        let output: std::option::Option<f32> = bevy::math::Ray2d::intersect_plane(
+                &_self,
+                plane_origin.into_inner(),
+                plane.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(
+        origin: Val<bevy::math::prelude::Vec2>,
+        direction: Val<bevy::math::prelude::Dir2>,
+    ) {
+        let output: Val<bevy::math::Ray2d> = bevy::math::Ray2d::new(
+                origin.into_inner(),
+                direction.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "ray_3_d")]
+impl bevy::math::Ray3d {
+    fn clone(_self: Ref<bevy::math::Ray3d>) {
+        let output: Val<bevy::math::Ray3d> = <bevy::math::Ray3d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::Ray3d>, other: Ref<bevy::math::Ray3d>) {
+        let output: bool = <bevy::math::Ray3d as std::cmp::PartialEq<
+            bevy::math::Ray3d,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn get_point(_self: Ref<bevy::math::Ray3d>, distance: f32) {
+        let output: Val<bevy::math::prelude::Vec3> = bevy::math::Ray3d::get_point(
+                &_self,
+                distance,
+            )
+            .into();
+        output
+    }
+    fn intersect_plane(
+        _self: Ref<bevy::math::Ray3d>,
+        plane_origin: Val<bevy::math::prelude::Vec3>,
+        plane: Val<bevy::math::primitives::InfinitePlane3d>,
+    ) {
+        let output: std::option::Option<f32> = bevy::math::Ray3d::intersect_plane(
+                &_self,
+                plane_origin.into_inner(),
+                plane.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(
+        origin: Val<bevy::math::prelude::Vec3>,
+        direction: Val<bevy::math::prelude::Dir3>,
+    ) {
+        let output: Val<bevy::math::Ray3d> = bevy::math::Ray3d::new(
+                origin.into_inner(),
+                direction.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "rot_2")]
+impl bevy::math::Rot2 {
+    fn angle_between(_self: Val<bevy::math::Rot2>, other: Val<bevy::math::Rot2>) {
+        let output: f32 = bevy::math::Rot2::angle_between(
+                _self.into_inner(),
+                other.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn angle_to(_self: Val<bevy::math::Rot2>, other: Val<bevy::math::Rot2>) {
+        let output: f32 = bevy::math::Rot2::angle_to(
+                _self.into_inner(),
+                other.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn as_degrees(_self: Val<bevy::math::Rot2>) {
+        let output: f32 = bevy::math::Rot2::as_degrees(_self.into_inner()).into();
+        output
+    }
+    fn as_radians(_self: Val<bevy::math::Rot2>) {
+        let output: f32 = bevy::math::Rot2::as_radians(_self.into_inner()).into();
+        output
+    }
+    fn as_turn_fraction(_self: Val<bevy::math::Rot2>) {
+        let output: f32 = bevy::math::Rot2::as_turn_fraction(_self.into_inner()).into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::Rot2>) {
+        let output: Val<bevy::math::Rot2> = <bevy::math::Rot2 as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn degrees(degrees: f32) {
+        let output: Val<bevy::math::Rot2> = bevy::math::Rot2::degrees(degrees).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::Rot2>, other: Ref<bevy::math::Rot2>) {
+        let output: bool = <bevy::math::Rot2 as std::cmp::PartialEq<
+            bevy::math::Rot2,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn fast_renormalize(_self: Val<bevy::math::Rot2>) {
+        let output: Val<bevy::math::Rot2> = bevy::math::Rot2::fast_renormalize(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_sin_cos(sin: f32, cos: f32) {
+        let output: Val<bevy::math::Rot2> = bevy::math::Rot2::from_sin_cos(sin, cos)
+            .into();
+        output
+    }
+    fn inverse(_self: Val<bevy::math::Rot2>) {
+        let output: Val<bevy::math::Rot2> = bevy::math::Rot2::inverse(_self.into_inner())
+            .into();
+        output
+    }
+    fn is_finite(_self: Val<bevy::math::Rot2>) {
+        let output: bool = bevy::math::Rot2::is_finite(_self.into_inner()).into();
+        output
+    }
+    fn is_nan(_self: Val<bevy::math::Rot2>) {
+        let output: bool = bevy::math::Rot2::is_nan(_self.into_inner()).into();
+        output
+    }
+    fn is_near_identity(_self: Val<bevy::math::Rot2>) {
+        let output: bool = bevy::math::Rot2::is_near_identity(_self.into_inner()).into();
+        output
+    }
+    fn is_normalized(_self: Val<bevy::math::Rot2>) {
+        let output: bool = bevy::math::Rot2::is_normalized(_self.into_inner()).into();
+        output
+    }
+    fn length(_self: Val<bevy::math::Rot2>) {
+        let output: f32 = bevy::math::Rot2::length(_self.into_inner()).into();
+        output
+    }
+    fn length_recip(_self: Val<bevy::math::Rot2>) {
+        let output: f32 = bevy::math::Rot2::length_recip(_self.into_inner()).into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::Rot2>) {
+        let output: f32 = bevy::math::Rot2::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Rot2>, rhs: Val<bevy::math::Rot2>) {
+        let output: Val<bevy::math::Rot2> = <bevy::math::Rot2 as std::ops::Mul<
+            bevy::math::Rot2,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Rot2>, direction: Val<bevy::math::prelude::Dir2>) {
+        let output: Val<bevy::math::prelude::Dir2> = <bevy::math::Rot2 as std::ops::Mul<
+            bevy::math::prelude::Dir2,
+        >>::mul(_self.into_inner(), direction.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Rot2>, rhs: Val<bevy::math::prelude::Vec2>) {
+        let output: Val<bevy::math::prelude::Vec2> = <bevy::math::Rot2 as std::ops::Mul<
+            bevy::math::prelude::Vec2,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn nlerp(_self: Val<bevy::math::Rot2>, end: Val<bevy::math::Rot2>, s: f32) {
+        let output: Val<bevy::math::Rot2> = bevy::math::Rot2::nlerp(
+                _self.into_inner(),
+                end.into_inner(),
+                s,
+            )
+            .into();
+        output
+    }
+    fn normalize(_self: Val<bevy::math::Rot2>) {
+        let output: Val<bevy::math::Rot2> = bevy::math::Rot2::normalize(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn radians(radians: f32) {
+        let output: Val<bevy::math::Rot2> = bevy::math::Rot2::radians(radians).into();
+        output
+    }
+    fn sin_cos(_self: Val<bevy::math::Rot2>) {
+        let output: (f32, f32) = bevy::math::Rot2::sin_cos(_self.into_inner()).into();
+        output
+    }
+    fn slerp(_self: Val<bevy::math::Rot2>, end: Val<bevy::math::Rot2>, s: f32) {
+        let output: Val<bevy::math::Rot2> = bevy::math::Rot2::slerp(
+                _self.into_inner(),
+                end.into_inner(),
+                s,
+            )
+            .into();
+        output
+    }
+    fn turn_fraction(fraction: f32) {
+        let output: Val<bevy::math::Rot2> = bevy::math::Rot2::turn_fraction(fraction)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "dir_2")]
+impl bevy::math::prelude::Dir2 {
+    fn as_vec2(_self: Ref<bevy::math::prelude::Dir2>) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::prelude::Dir2::as_vec2(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::prelude::Dir2>) {
+        let output: Val<bevy::math::prelude::Dir2> = <bevy::math::prelude::Dir2 as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::prelude::Dir2>, other: Ref<bevy::math::prelude::Dir2>) {
+        let output: bool = <bevy::math::prelude::Dir2 as std::cmp::PartialEq<
+            bevy::math::prelude::Dir2,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn fast_renormalize(_self: Val<bevy::math::prelude::Dir2>) {
+        let output: Val<bevy::math::prelude::Dir2> = bevy::math::prelude::Dir2::fast_renormalize(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_xy_unchecked(x: f32, y: f32) {
+        let output: Val<bevy::math::prelude::Dir2> = bevy::math::prelude::Dir2::from_xy_unchecked(
+                x,
+                y,
+            )
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::prelude::Dir2>, rhs: f32) {
+        let output: Val<bevy::math::prelude::Vec2> = <bevy::math::prelude::Dir2 as std::ops::Mul<
+            f32,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::prelude::Dir2>) {
+        let output: Val<bevy::math::prelude::Dir2> = <bevy::math::prelude::Dir2 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new_unchecked(value: Val<bevy::math::prelude::Vec2>) {
+        let output: Val<bevy::math::prelude::Dir2> = bevy::math::prelude::Dir2::new_unchecked(
+                value.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rotation_from(
+        _self: Val<bevy::math::prelude::Dir2>,
+        other: Val<bevy::math::prelude::Dir2>,
+    ) {
+        let output: Val<bevy::math::Rot2> = bevy::math::prelude::Dir2::rotation_from(
+                _self.into_inner(),
+                other.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rotation_from_x(_self: Val<bevy::math::prelude::Dir2>) {
+        let output: Val<bevy::math::Rot2> = bevy::math::prelude::Dir2::rotation_from_x(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rotation_from_y(_self: Val<bevy::math::prelude::Dir2>) {
+        let output: Val<bevy::math::Rot2> = bevy::math::prelude::Dir2::rotation_from_y(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rotation_to(
+        _self: Val<bevy::math::prelude::Dir2>,
+        other: Val<bevy::math::prelude::Dir2>,
+    ) {
+        let output: Val<bevy::math::Rot2> = bevy::math::prelude::Dir2::rotation_to(
+                _self.into_inner(),
+                other.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rotation_to_x(_self: Val<bevy::math::prelude::Dir2>) {
+        let output: Val<bevy::math::Rot2> = bevy::math::prelude::Dir2::rotation_to_x(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rotation_to_y(_self: Val<bevy::math::prelude::Dir2>) {
+        let output: Val<bevy::math::Rot2> = bevy::math::prelude::Dir2::rotation_to_y(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn slerp(
+        _self: Val<bevy::math::prelude::Dir2>,
+        rhs: Val<bevy::math::prelude::Dir2>,
+        s: f32,
+    ) {
+        let output: Val<bevy::math::prelude::Dir2> = bevy::math::prelude::Dir2::slerp(
+                _self.into_inner(),
+                rhs.into_inner(),
+                s,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "dir_3")]
+impl bevy::math::prelude::Dir3 {
+    fn as_vec3(_self: Ref<bevy::math::prelude::Dir3>) {
+        let output: Val<bevy::math::prelude::Vec3> = bevy::math::prelude::Dir3::as_vec3(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::prelude::Dir3>) {
+        let output: Val<bevy::math::prelude::Dir3> = <bevy::math::prelude::Dir3 as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::prelude::Dir3>, other: Ref<bevy::math::prelude::Dir3>) {
+        let output: bool = <bevy::math::prelude::Dir3 as std::cmp::PartialEq<
+            bevy::math::prelude::Dir3,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn fast_renormalize(_self: Val<bevy::math::prelude::Dir3>) {
+        let output: Val<bevy::math::prelude::Dir3> = bevy::math::prelude::Dir3::fast_renormalize(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_xyz_unchecked(x: f32, y: f32, z: f32) {
+        let output: Val<bevy::math::prelude::Dir3> = bevy::math::prelude::Dir3::from_xyz_unchecked(
+                x,
+                y,
+                z,
+            )
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::prelude::Dir3>, rhs: f32) {
+        let output: Val<bevy::math::prelude::Vec3> = <bevy::math::prelude::Dir3 as std::ops::Mul<
+            f32,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::prelude::Dir3>) {
+        let output: Val<bevy::math::prelude::Dir3> = <bevy::math::prelude::Dir3 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new_unchecked(value: Val<bevy::math::prelude::Vec3>) {
+        let output: Val<bevy::math::prelude::Dir3> = bevy::math::prelude::Dir3::new_unchecked(
+                value.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn slerp(
+        _self: Val<bevy::math::prelude::Dir3>,
+        rhs: Val<bevy::math::prelude::Dir3>,
+        s: f32,
+    ) {
+        let output: Val<bevy::math::prelude::Dir3> = bevy::math::prelude::Dir3::slerp(
+                _self.into_inner(),
+                rhs.into_inner(),
+                s,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "dir_3_a")]
+impl bevy::math::prelude::Dir3A {
+    fn as_vec3a(_self: Ref<bevy::math::prelude::Dir3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::prelude::Dir3A::as_vec3a(&_self)
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::prelude::Dir3A>) {
+        let output: Val<bevy::math::prelude::Dir3A> = <bevy::math::prelude::Dir3A as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::prelude::Dir3A>,
+        other: Ref<bevy::math::prelude::Dir3A>,
+    ) {
+        let output: bool = <bevy::math::prelude::Dir3A as std::cmp::PartialEq<
+            bevy::math::prelude::Dir3A,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn fast_renormalize(_self: Val<bevy::math::prelude::Dir3A>) {
+        let output: Val<bevy::math::prelude::Dir3A> = bevy::math::prelude::Dir3A::fast_renormalize(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_xyz_unchecked(x: f32, y: f32, z: f32) {
+        let output: Val<bevy::math::prelude::Dir3A> = bevy::math::prelude::Dir3A::from_xyz_unchecked(
+                x,
+                y,
+                z,
+            )
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::prelude::Dir3A>, rhs: f32) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::prelude::Dir3A as std::ops::Mul<
+            f32,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::prelude::Dir3A>) {
+        let output: Val<bevy::math::prelude::Dir3A> = <bevy::math::prelude::Dir3A as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new_unchecked(value: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::prelude::Dir3A> = bevy::math::prelude::Dir3A::new_unchecked(
+                value.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn slerp(
+        _self: Val<bevy::math::prelude::Dir3A>,
+        rhs: Val<bevy::math::prelude::Dir3A>,
+        s: f32,
+    ) {
+        let output: Val<bevy::math::prelude::Dir3A> = bevy::math::prelude::Dir3A::slerp(
+                _self.into_inner(),
+                rhs.into_inner(),
+                s,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "i_rect")]
+impl bevy::math::prelude::IRect {
+    fn as_rect(_self: Ref<bevy::math::prelude::IRect>) {
+        let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::IRect::as_rect(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn as_urect(_self: Ref<bevy::math::prelude::IRect>) {
+        let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::IRect::as_urect(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::prelude::IRect>) {
+        let output: () = <bevy::math::prelude::IRect as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn center(_self: Ref<bevy::math::prelude::IRect>) {
+        let output: Val<bevy::math::prelude::IVec2> = bevy::math::prelude::IRect::center(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::prelude::IRect>) {
+        let output: Val<bevy::math::prelude::IRect> = <bevy::math::prelude::IRect as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn contains(
+        _self: Ref<bevy::math::prelude::IRect>,
+        point: Val<bevy::math::prelude::IVec2>,
+    ) {
+        let output: bool = bevy::math::prelude::IRect::contains(
+                &_self,
+                point.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::prelude::IRect>,
+        other: Ref<bevy::math::prelude::IRect>,
+    ) {
+        let output: bool = <bevy::math::prelude::IRect as std::cmp::PartialEq<
+            bevy::math::prelude::IRect,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_center_half_size(
+        origin: Val<bevy::math::prelude::IVec2>,
+        half_size: Val<bevy::math::prelude::IVec2>,
+    ) {
+        let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::IRect::from_center_half_size(
+                origin.into_inner(),
+                half_size.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_center_size(
+        origin: Val<bevy::math::prelude::IVec2>,
+        size: Val<bevy::math::prelude::IVec2>,
+    ) {
+        let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::IRect::from_center_size(
+                origin.into_inner(),
+                size.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_corners(
+        p0: Val<bevy::math::prelude::IVec2>,
+        p1: Val<bevy::math::prelude::IVec2>,
+    ) {
+        let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::IRect::from_corners(
+                p0.into_inner(),
+                p1.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn half_size(_self: Ref<bevy::math::prelude::IRect>) {
+        let output: Val<bevy::math::prelude::IVec2> = bevy::math::prelude::IRect::half_size(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn height(_self: Ref<bevy::math::prelude::IRect>) {
+        let output: i32 = bevy::math::prelude::IRect::height(&_self).into();
+        output
+    }
+    fn inflate(_self: Ref<bevy::math::prelude::IRect>, expansion: i32) {
+        let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::IRect::inflate(
+                &_self,
+                expansion,
+            )
+            .into();
+        output
+    }
+    fn intersect(
+        _self: Ref<bevy::math::prelude::IRect>,
+        other: Val<bevy::math::prelude::IRect>,
+    ) {
+        let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::IRect::intersect(
+                &_self,
+                other.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn is_empty(_self: Ref<bevy::math::prelude::IRect>) {
+        let output: bool = bevy::math::prelude::IRect::is_empty(&_self).into();
+        output
+    }
+    fn new(x0: i32, y0: i32, x1: i32, y1: i32) {
+        let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::IRect::new(
+                x0,
+                y0,
+                x1,
+                y1,
+            )
+            .into();
+        output
+    }
+    fn size(_self: Ref<bevy::math::prelude::IRect>) {
+        let output: Val<bevy::math::prelude::IVec2> = bevy::math::prelude::IRect::size(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn union(
+        _self: Ref<bevy::math::prelude::IRect>,
+        other: Val<bevy::math::prelude::IRect>,
+    ) {
+        let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::IRect::union(
+                &_self,
+                other.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn union_point(
+        _self: Ref<bevy::math::prelude::IRect>,
+        other: Val<bevy::math::prelude::IVec2>,
+    ) {
+        let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::IRect::union_point(
+                &_self,
+                other.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn width(_self: Ref<bevy::math::prelude::IRect>) {
+        let output: i32 = bevy::math::prelude::IRect::width(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "rect")]
+impl bevy::math::prelude::Rect {
+    fn as_irect(_self: Ref<bevy::math::prelude::Rect>) {
+        let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::Rect::as_irect(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn as_urect(_self: Ref<bevy::math::prelude::Rect>) {
+        let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::Rect::as_urect(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn center(_self: Ref<bevy::math::prelude::Rect>) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::prelude::Rect::center(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::prelude::Rect>) {
+        let output: Val<bevy::math::prelude::Rect> = <bevy::math::prelude::Rect as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn contains(
+        _self: Ref<bevy::math::prelude::Rect>,
+        point: Val<bevy::math::prelude::Vec2>,
+    ) {
+        let output: bool = bevy::math::prelude::Rect::contains(
+                &_self,
+                point.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::prelude::Rect>, other: Ref<bevy::math::prelude::Rect>) {
+        let output: bool = <bevy::math::prelude::Rect as std::cmp::PartialEq<
+            bevy::math::prelude::Rect,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_center_half_size(
+        origin: Val<bevy::math::prelude::Vec2>,
+        half_size: Val<bevy::math::prelude::Vec2>,
+    ) {
+        let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::Rect::from_center_half_size(
+                origin.into_inner(),
+                half_size.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_center_size(
+        origin: Val<bevy::math::prelude::Vec2>,
+        size: Val<bevy::math::prelude::Vec2>,
+    ) {
+        let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::Rect::from_center_size(
+                origin.into_inner(),
+                size.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_corners(
+        p0: Val<bevy::math::prelude::Vec2>,
+        p1: Val<bevy::math::prelude::Vec2>,
+    ) {
+        let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::Rect::from_corners(
+                p0.into_inner(),
+                p1.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn half_size(_self: Ref<bevy::math::prelude::Rect>) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::prelude::Rect::half_size(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn height(_self: Ref<bevy::math::prelude::Rect>) {
+        let output: f32 = bevy::math::prelude::Rect::height(&_self).into();
+        output
+    }
+    fn inflate(_self: Ref<bevy::math::prelude::Rect>, expansion: f32) {
+        let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::Rect::inflate(
+                &_self,
+                expansion,
+            )
+            .into();
+        output
+    }
+    fn intersect(
+        _self: Ref<bevy::math::prelude::Rect>,
+        other: Val<bevy::math::prelude::Rect>,
+    ) {
+        let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::Rect::intersect(
+                &_self,
+                other.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn is_empty(_self: Ref<bevy::math::prelude::Rect>) {
+        let output: bool = bevy::math::prelude::Rect::is_empty(&_self).into();
+        output
+    }
+    fn new(x0: f32, y0: f32, x1: f32, y1: f32) {
+        let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::Rect::new(
+                x0,
+                y0,
+                x1,
+                y1,
+            )
+            .into();
+        output
+    }
+    fn normalize(
+        _self: Ref<bevy::math::prelude::Rect>,
+        other: Val<bevy::math::prelude::Rect>,
+    ) {
+        let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::Rect::normalize(
+                &_self,
+                other.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn size(_self: Ref<bevy::math::prelude::Rect>) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::prelude::Rect::size(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn union(
+        _self: Ref<bevy::math::prelude::Rect>,
+        other: Val<bevy::math::prelude::Rect>,
+    ) {
+        let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::Rect::union(
+                &_self,
+                other.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn union_point(
+        _self: Ref<bevy::math::prelude::Rect>,
+        other: Val<bevy::math::prelude::Vec2>,
+    ) {
+        let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::Rect::union_point(
+                &_self,
+                other.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn width(_self: Ref<bevy::math::prelude::Rect>) {
+        let output: f32 = bevy::math::prelude::Rect::width(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "u_rect")]
+impl bevy::math::prelude::URect {
+    fn as_irect(_self: Ref<bevy::math::prelude::URect>) {
+        let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::URect::as_irect(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn as_rect(_self: Ref<bevy::math::prelude::URect>) {
+        let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::URect::as_rect(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::prelude::URect>) {
+        let output: () = <bevy::math::prelude::URect as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn center(_self: Ref<bevy::math::prelude::URect>) {
+        let output: Val<bevy::math::prelude::UVec2> = bevy::math::prelude::URect::center(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::prelude::URect>) {
+        let output: Val<bevy::math::prelude::URect> = <bevy::math::prelude::URect as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn contains(
+        _self: Ref<bevy::math::prelude::URect>,
+        point: Val<bevy::math::prelude::UVec2>,
+    ) {
+        let output: bool = bevy::math::prelude::URect::contains(
+                &_self,
+                point.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::prelude::URect>,
+        other: Ref<bevy::math::prelude::URect>,
+    ) {
+        let output: bool = <bevy::math::prelude::URect as std::cmp::PartialEq<
+            bevy::math::prelude::URect,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_center_half_size(
+        origin: Val<bevy::math::prelude::UVec2>,
+        half_size: Val<bevy::math::prelude::UVec2>,
+    ) {
+        let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::URect::from_center_half_size(
+                origin.into_inner(),
+                half_size.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_center_size(
+        origin: Val<bevy::math::prelude::UVec2>,
+        size: Val<bevy::math::prelude::UVec2>,
+    ) {
+        let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::URect::from_center_size(
+                origin.into_inner(),
+                size.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_corners(
+        p0: Val<bevy::math::prelude::UVec2>,
+        p1: Val<bevy::math::prelude::UVec2>,
+    ) {
+        let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::URect::from_corners(
+                p0.into_inner(),
+                p1.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn half_size(_self: Ref<bevy::math::prelude::URect>) {
+        let output: Val<bevy::math::prelude::UVec2> = bevy::math::prelude::URect::half_size(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn height(_self: Ref<bevy::math::prelude::URect>) {
+        let output: u32 = bevy::math::prelude::URect::height(&_self).into();
+        output
+    }
+    fn inflate(_self: Ref<bevy::math::prelude::URect>, expansion: i32) {
+        let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::URect::inflate(
+                &_self,
+                expansion,
+            )
+            .into();
+        output
+    }
+    fn intersect(
+        _self: Ref<bevy::math::prelude::URect>,
+        other: Val<bevy::math::prelude::URect>,
+    ) {
+        let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::URect::intersect(
+                &_self,
+                other.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn is_empty(_self: Ref<bevy::math::prelude::URect>) {
+        let output: bool = bevy::math::prelude::URect::is_empty(&_self).into();
+        output
+    }
+    fn new(x0: u32, y0: u32, x1: u32, y1: u32) {
+        let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::URect::new(
+                x0,
+                y0,
+                x1,
+                y1,
+            )
+            .into();
+        output
+    }
+    fn size(_self: Ref<bevy::math::prelude::URect>) {
+        let output: Val<bevy::math::prelude::UVec2> = bevy::math::prelude::URect::size(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn union(
+        _self: Ref<bevy::math::prelude::URect>,
+        other: Val<bevy::math::prelude::URect>,
+    ) {
+        let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::URect::union(
+                &_self,
+                other.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn union_point(
+        _self: Ref<bevy::math::prelude::URect>,
+        other: Val<bevy::math::prelude::UVec2>,
+    ) {
+        let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::URect::union_point(
+                &_self,
+                other.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn width(_self: Ref<bevy::math::prelude::URect>) {
+        let output: u32 = bevy::math::prelude::URect::width(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "affine_3")]
+impl bevy::math::Affine3 {}
+#[script_bindings(remote, name = "aabb_2_d")]
+impl bevy::math::bounding::Aabb2d {
+    fn bounding_circle(_self: Ref<bevy::math::bounding::Aabb2d>) {
+        let output: Val<bevy::math::bounding::BoundingCircle> = bevy::math::bounding::Aabb2d::bounding_circle(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::bounding::Aabb2d>) {
+        let output: Val<bevy::math::bounding::Aabb2d> = <bevy::math::bounding::Aabb2d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn closest_point(
+        _self: Ref<bevy::math::bounding::Aabb2d>,
+        point: Val<bevy::math::prelude::Vec2>,
+    ) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::bounding::Aabb2d::closest_point(
+                &_self,
+                point.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(
+        center: Val<bevy::math::prelude::Vec2>,
+        half_size: Val<bevy::math::prelude::Vec2>,
+    ) {
+        let output: Val<bevy::math::bounding::Aabb2d> = bevy::math::bounding::Aabb2d::new(
+                center.into_inner(),
+                half_size.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "bounding_circle")]
+impl bevy::math::bounding::BoundingCircle {
+    fn aabb_2d(_self: Ref<bevy::math::bounding::BoundingCircle>) {
+        let output: Val<bevy::math::bounding::Aabb2d> = bevy::math::bounding::BoundingCircle::aabb_2d(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::bounding::BoundingCircle>) {
+        let output: Val<bevy::math::bounding::BoundingCircle> = <bevy::math::bounding::BoundingCircle as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn closest_point(
+        _self: Ref<bevy::math::bounding::BoundingCircle>,
+        point: Val<bevy::math::prelude::Vec2>,
+    ) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::bounding::BoundingCircle::closest_point(
+                &_self,
+                point.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(center: Val<bevy::math::prelude::Vec2>, radius: f32) {
+        let output: Val<bevy::math::bounding::BoundingCircle> = bevy::math::bounding::BoundingCircle::new(
+                center.into_inner(),
+                radius,
+            )
+            .into();
+        output
+    }
+    fn radius(_self: Ref<bevy::math::bounding::BoundingCircle>) {
+        let output: f32 = bevy::math::bounding::BoundingCircle::radius(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "circle")]
+impl bevy::math::primitives::Circle {
+    fn clone(_self: Ref<bevy::math::primitives::Circle>) {
+        let output: Val<bevy::math::primitives::Circle> = <bevy::math::primitives::Circle as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn closest_point(
+        _self: Ref<bevy::math::primitives::Circle>,
+        point: Val<bevy::math::prelude::Vec2>,
+    ) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Circle::closest_point(
+                &_self,
+                point.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn diameter(_self: Ref<bevy::math::primitives::Circle>) {
+        let output: f32 = bevy::math::primitives::Circle::diameter(&_self).into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Circle>,
+        other: Ref<bevy::math::primitives::Circle>,
+    ) {
+        let output: bool = <bevy::math::primitives::Circle as std::cmp::PartialEq<
+            bevy::math::primitives::Circle,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn new(radius: f32) {
+        let output: Val<bevy::math::primitives::Circle> = bevy::math::primitives::Circle::new(
+                radius,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "annulus")]
+impl bevy::math::primitives::Annulus {
+    fn clone(_self: Ref<bevy::math::primitives::Annulus>) {
+        let output: Val<bevy::math::primitives::Annulus> = <bevy::math::primitives::Annulus as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn closest_point(
+        _self: Ref<bevy::math::primitives::Annulus>,
+        point: Val<bevy::math::prelude::Vec2>,
+    ) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Annulus::closest_point(
+                &_self,
+                point.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn diameter(_self: Ref<bevy::math::primitives::Annulus>) {
+        let output: f32 = bevy::math::primitives::Annulus::diameter(&_self).into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Annulus>,
+        other: Ref<bevy::math::primitives::Annulus>,
+    ) {
+        let output: bool = <bevy::math::primitives::Annulus as std::cmp::PartialEq<
+            bevy::math::primitives::Annulus,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn new(inner_radius: f32, outer_radius: f32) {
+        let output: Val<bevy::math::primitives::Annulus> = bevy::math::primitives::Annulus::new(
+                inner_radius,
+                outer_radius,
+            )
+            .into();
+        output
+    }
+    fn thickness(_self: Ref<bevy::math::primitives::Annulus>) {
+        let output: f32 = bevy::math::primitives::Annulus::thickness(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "arc_2_d")]
+impl bevy::math::primitives::Arc2d {
+    fn angle(_self: Ref<bevy::math::primitives::Arc2d>) {
+        let output: f32 = bevy::math::primitives::Arc2d::angle(&_self).into();
+        output
+    }
+    fn apothem(_self: Ref<bevy::math::primitives::Arc2d>) {
+        let output: f32 = bevy::math::primitives::Arc2d::apothem(&_self).into();
+        output
+    }
+    fn chord_length(_self: Ref<bevy::math::primitives::Arc2d>) {
+        let output: f32 = bevy::math::primitives::Arc2d::chord_length(&_self).into();
+        output
+    }
+    fn chord_midpoint(_self: Ref<bevy::math::primitives::Arc2d>) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Arc2d::chord_midpoint(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::primitives::Arc2d>) {
+        let output: Val<bevy::math::primitives::Arc2d> = <bevy::math::primitives::Arc2d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Arc2d>,
+        other: Ref<bevy::math::primitives::Arc2d>,
+    ) {
+        let output: bool = <bevy::math::primitives::Arc2d as std::cmp::PartialEq<
+            bevy::math::primitives::Arc2d,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_degrees(radius: f32, angle: f32) {
+        let output: Val<bevy::math::primitives::Arc2d> = bevy::math::primitives::Arc2d::from_degrees(
+                radius,
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_radians(radius: f32, angle: f32) {
+        let output: Val<bevy::math::primitives::Arc2d> = bevy::math::primitives::Arc2d::from_radians(
+                radius,
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_turns(radius: f32, fraction: f32) {
+        let output: Val<bevy::math::primitives::Arc2d> = bevy::math::primitives::Arc2d::from_turns(
+                radius,
+                fraction,
+            )
+            .into();
+        output
+    }
+    fn half_chord_length(_self: Ref<bevy::math::primitives::Arc2d>) {
+        let output: f32 = bevy::math::primitives::Arc2d::half_chord_length(&_self)
+            .into();
+        output
+    }
+    fn is_major(_self: Ref<bevy::math::primitives::Arc2d>) {
+        let output: bool = bevy::math::primitives::Arc2d::is_major(&_self).into();
+        output
+    }
+    fn is_minor(_self: Ref<bevy::math::primitives::Arc2d>) {
+        let output: bool = bevy::math::primitives::Arc2d::is_minor(&_self).into();
+        output
+    }
+    fn left_endpoint(_self: Ref<bevy::math::primitives::Arc2d>) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Arc2d::left_endpoint(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn length(_self: Ref<bevy::math::primitives::Arc2d>) {
+        let output: f32 = bevy::math::primitives::Arc2d::length(&_self).into();
+        output
+    }
+    fn midpoint(_self: Ref<bevy::math::primitives::Arc2d>) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Arc2d::midpoint(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn new(radius: f32, half_angle: f32) {
+        let output: Val<bevy::math::primitives::Arc2d> = bevy::math::primitives::Arc2d::new(
+                radius,
+                half_angle,
+            )
+            .into();
+        output
+    }
+    fn right_endpoint(_self: Ref<bevy::math::primitives::Arc2d>) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Arc2d::right_endpoint(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn sagitta(_self: Ref<bevy::math::primitives::Arc2d>) {
+        let output: f32 = bevy::math::primitives::Arc2d::sagitta(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "capsule_2_d")]
+impl bevy::math::primitives::Capsule2d {
+    fn clone(_self: Ref<bevy::math::primitives::Capsule2d>) {
+        let output: Val<bevy::math::primitives::Capsule2d> = <bevy::math::primitives::Capsule2d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Capsule2d>,
+        other: Ref<bevy::math::primitives::Capsule2d>,
+    ) {
+        let output: bool = <bevy::math::primitives::Capsule2d as std::cmp::PartialEq<
+            bevy::math::primitives::Capsule2d,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn new(radius: f32, length: f32) {
+        let output: Val<bevy::math::primitives::Capsule2d> = bevy::math::primitives::Capsule2d::new(
+                radius,
+                length,
+            )
+            .into();
+        output
+    }
+    fn to_inner_rectangle(_self: Ref<bevy::math::primitives::Capsule2d>) {
+        let output: Val<bevy::math::primitives::Rectangle> = bevy::math::primitives::Capsule2d::to_inner_rectangle(
+                &_self,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "circular_sector")]
+impl bevy::math::primitives::CircularSector {
+    fn angle(_self: Ref<bevy::math::primitives::CircularSector>) {
+        let output: f32 = bevy::math::primitives::CircularSector::angle(&_self).into();
+        output
+    }
+    fn apothem(_self: Ref<bevy::math::primitives::CircularSector>) {
+        let output: f32 = bevy::math::primitives::CircularSector::apothem(&_self).into();
+        output
+    }
+    fn arc_length(_self: Ref<bevy::math::primitives::CircularSector>) {
+        let output: f32 = bevy::math::primitives::CircularSector::arc_length(&_self)
+            .into();
+        output
+    }
+    fn chord_length(_self: Ref<bevy::math::primitives::CircularSector>) {
+        let output: f32 = bevy::math::primitives::CircularSector::chord_length(&_self)
+            .into();
+        output
+    }
+    fn chord_midpoint(_self: Ref<bevy::math::primitives::CircularSector>) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::CircularSector::chord_midpoint(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::primitives::CircularSector>) {
+        let output: Val<bevy::math::primitives::CircularSector> = <bevy::math::primitives::CircularSector as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::CircularSector>,
+        other: Ref<bevy::math::primitives::CircularSector>,
+    ) {
+        let output: bool = <bevy::math::primitives::CircularSector as std::cmp::PartialEq<
+            bevy::math::primitives::CircularSector,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_degrees(radius: f32, angle: f32) {
+        let output: Val<bevy::math::primitives::CircularSector> = bevy::math::primitives::CircularSector::from_degrees(
+                radius,
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_radians(radius: f32, angle: f32) {
+        let output: Val<bevy::math::primitives::CircularSector> = bevy::math::primitives::CircularSector::from_radians(
+                radius,
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_turns(radius: f32, fraction: f32) {
+        let output: Val<bevy::math::primitives::CircularSector> = bevy::math::primitives::CircularSector::from_turns(
+                radius,
+                fraction,
+            )
+            .into();
+        output
+    }
+    fn half_angle(_self: Ref<bevy::math::primitives::CircularSector>) {
+        let output: f32 = bevy::math::primitives::CircularSector::half_angle(&_self)
+            .into();
+        output
+    }
+    fn half_chord_length(_self: Ref<bevy::math::primitives::CircularSector>) {
+        let output: f32 = bevy::math::primitives::CircularSector::half_chord_length(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn new(radius: f32, angle: f32) {
+        let output: Val<bevy::math::primitives::CircularSector> = bevy::math::primitives::CircularSector::new(
+                radius,
+                angle,
+            )
+            .into();
+        output
+    }
+    fn radius(_self: Ref<bevy::math::primitives::CircularSector>) {
+        let output: f32 = bevy::math::primitives::CircularSector::radius(&_self).into();
+        output
+    }
+    fn sagitta(_self: Ref<bevy::math::primitives::CircularSector>) {
+        let output: f32 = bevy::math::primitives::CircularSector::sagitta(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "circular_segment")]
+impl bevy::math::primitives::CircularSegment {
+    fn angle(_self: Ref<bevy::math::primitives::CircularSegment>) {
+        let output: f32 = bevy::math::primitives::CircularSegment::angle(&_self).into();
+        output
+    }
+    fn apothem(_self: Ref<bevy::math::primitives::CircularSegment>) {
+        let output: f32 = bevy::math::primitives::CircularSegment::apothem(&_self)
+            .into();
+        output
+    }
+    fn arc_length(_self: Ref<bevy::math::primitives::CircularSegment>) {
+        let output: f32 = bevy::math::primitives::CircularSegment::arc_length(&_self)
+            .into();
+        output
+    }
+    fn chord_length(_self: Ref<bevy::math::primitives::CircularSegment>) {
+        let output: f32 = bevy::math::primitives::CircularSegment::chord_length(&_self)
+            .into();
+        output
+    }
+    fn chord_midpoint(_self: Ref<bevy::math::primitives::CircularSegment>) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::CircularSegment::chord_midpoint(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::primitives::CircularSegment>) {
+        let output: Val<bevy::math::primitives::CircularSegment> = <bevy::math::primitives::CircularSegment as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::CircularSegment>,
+        other: Ref<bevy::math::primitives::CircularSegment>,
+    ) {
+        let output: bool = <bevy::math::primitives::CircularSegment as std::cmp::PartialEq<
+            bevy::math::primitives::CircularSegment,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_degrees(radius: f32, angle: f32) {
+        let output: Val<bevy::math::primitives::CircularSegment> = bevy::math::primitives::CircularSegment::from_degrees(
+                radius,
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_radians(radius: f32, angle: f32) {
+        let output: Val<bevy::math::primitives::CircularSegment> = bevy::math::primitives::CircularSegment::from_radians(
+                radius,
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_turns(radius: f32, fraction: f32) {
+        let output: Val<bevy::math::primitives::CircularSegment> = bevy::math::primitives::CircularSegment::from_turns(
+                radius,
+                fraction,
+            )
+            .into();
+        output
+    }
+    fn half_angle(_self: Ref<bevy::math::primitives::CircularSegment>) {
+        let output: f32 = bevy::math::primitives::CircularSegment::half_angle(&_self)
+            .into();
+        output
+    }
+    fn half_chord_length(_self: Ref<bevy::math::primitives::CircularSegment>) {
+        let output: f32 = bevy::math::primitives::CircularSegment::half_chord_length(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn new(radius: f32, angle: f32) {
+        let output: Val<bevy::math::primitives::CircularSegment> = bevy::math::primitives::CircularSegment::new(
+                radius,
+                angle,
+            )
+            .into();
+        output
+    }
+    fn radius(_self: Ref<bevy::math::primitives::CircularSegment>) {
+        let output: f32 = bevy::math::primitives::CircularSegment::radius(&_self).into();
+        output
+    }
+    fn sagitta(_self: Ref<bevy::math::primitives::CircularSegment>) {
+        let output: f32 = bevy::math::primitives::CircularSegment::sagitta(&_self)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "ellipse")]
+impl bevy::math::primitives::Ellipse {
+    fn clone(_self: Ref<bevy::math::primitives::Ellipse>) {
+        let output: Val<bevy::math::primitives::Ellipse> = <bevy::math::primitives::Ellipse as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eccentricity(_self: Ref<bevy::math::primitives::Ellipse>) {
+        let output: f32 = bevy::math::primitives::Ellipse::eccentricity(&_self).into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Ellipse>,
+        other: Ref<bevy::math::primitives::Ellipse>,
+    ) {
+        let output: bool = <bevy::math::primitives::Ellipse as std::cmp::PartialEq<
+            bevy::math::primitives::Ellipse,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn focal_length(_self: Ref<bevy::math::primitives::Ellipse>) {
+        let output: f32 = bevy::math::primitives::Ellipse::focal_length(&_self).into();
+        output
+    }
+    fn from_size(size: Val<bevy::math::prelude::Vec2>) {
+        let output: Val<bevy::math::primitives::Ellipse> = bevy::math::primitives::Ellipse::from_size(
+                size.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(half_width: f32, half_height: f32) {
+        let output: Val<bevy::math::primitives::Ellipse> = bevy::math::primitives::Ellipse::new(
+                half_width,
+                half_height,
+            )
+            .into();
+        output
+    }
+    fn semi_major(_self: Ref<bevy::math::primitives::Ellipse>) {
+        let output: f32 = bevy::math::primitives::Ellipse::semi_major(&_self).into();
+        output
+    }
+    fn semi_minor(_self: Ref<bevy::math::primitives::Ellipse>) {
+        let output: f32 = bevy::math::primitives::Ellipse::semi_minor(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "line_2_d")]
+impl bevy::math::primitives::Line2d {
+    fn clone(_self: Ref<bevy::math::primitives::Line2d>) {
+        let output: Val<bevy::math::primitives::Line2d> = <bevy::math::primitives::Line2d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Line2d>,
+        other: Ref<bevy::math::primitives::Line2d>,
+    ) {
+        let output: bool = <bevy::math::primitives::Line2d as std::cmp::PartialEq<
+            bevy::math::primitives::Line2d,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "plane_2_d")]
+impl bevy::math::primitives::Plane2d {
+    fn clone(_self: Ref<bevy::math::primitives::Plane2d>) {
+        let output: Val<bevy::math::primitives::Plane2d> = <bevy::math::primitives::Plane2d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Plane2d>,
+        other: Ref<bevy::math::primitives::Plane2d>,
+    ) {
+        let output: bool = <bevy::math::primitives::Plane2d as std::cmp::PartialEq<
+            bevy::math::primitives::Plane2d,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn new(normal: Val<bevy::math::prelude::Vec2>) {
+        let output: Val<bevy::math::primitives::Plane2d> = bevy::math::primitives::Plane2d::new(
+                normal.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "rectangle")]
+impl bevy::math::primitives::Rectangle {
+    fn clone(_self: Ref<bevy::math::primitives::Rectangle>) {
+        let output: Val<bevy::math::primitives::Rectangle> = <bevy::math::primitives::Rectangle as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn closest_point(
+        _self: Ref<bevy::math::primitives::Rectangle>,
+        point: Val<bevy::math::prelude::Vec2>,
+    ) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Rectangle::closest_point(
+                &_self,
+                point.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Rectangle>,
+        other: Ref<bevy::math::primitives::Rectangle>,
+    ) {
+        let output: bool = <bevy::math::primitives::Rectangle as std::cmp::PartialEq<
+            bevy::math::primitives::Rectangle,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_corners(
+        point1: Val<bevy::math::prelude::Vec2>,
+        point2: Val<bevy::math::prelude::Vec2>,
+    ) {
+        let output: Val<bevy::math::primitives::Rectangle> = bevy::math::primitives::Rectangle::from_corners(
+                point1.into_inner(),
+                point2.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_length(length: f32) {
+        let output: Val<bevy::math::primitives::Rectangle> = bevy::math::primitives::Rectangle::from_length(
+                length,
+            )
+            .into();
+        output
+    }
+    fn from_size(size: Val<bevy::math::prelude::Vec2>) {
+        let output: Val<bevy::math::primitives::Rectangle> = bevy::math::primitives::Rectangle::from_size(
+                size.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(width: f32, height: f32) {
+        let output: Val<bevy::math::primitives::Rectangle> = bevy::math::primitives::Rectangle::new(
+                width,
+                height,
+            )
+            .into();
+        output
+    }
+    fn size(_self: Ref<bevy::math::primitives::Rectangle>) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Rectangle::size(
+                &_self,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "regular_polygon")]
+impl bevy::math::primitives::RegularPolygon {
+    fn circumradius(_self: Ref<bevy::math::primitives::RegularPolygon>) {
+        let output: f32 = bevy::math::primitives::RegularPolygon::circumradius(&_self)
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::primitives::RegularPolygon>) {
+        let output: Val<bevy::math::primitives::RegularPolygon> = <bevy::math::primitives::RegularPolygon as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::RegularPolygon>,
+        other: Ref<bevy::math::primitives::RegularPolygon>,
+    ) {
+        let output: bool = <bevy::math::primitives::RegularPolygon as std::cmp::PartialEq<
+            bevy::math::primitives::RegularPolygon,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn external_angle_degrees(_self: Ref<bevy::math::primitives::RegularPolygon>) {
+        let output: f32 = bevy::math::primitives::RegularPolygon::external_angle_degrees(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn external_angle_radians(_self: Ref<bevy::math::primitives::RegularPolygon>) {
+        let output: f32 = bevy::math::primitives::RegularPolygon::external_angle_radians(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn inradius(_self: Ref<bevy::math::primitives::RegularPolygon>) {
+        let output: f32 = bevy::math::primitives::RegularPolygon::inradius(&_self)
+            .into();
+        output
+    }
+    fn internal_angle_degrees(_self: Ref<bevy::math::primitives::RegularPolygon>) {
+        let output: f32 = bevy::math::primitives::RegularPolygon::internal_angle_degrees(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn internal_angle_radians(_self: Ref<bevy::math::primitives::RegularPolygon>) {
+        let output: f32 = bevy::math::primitives::RegularPolygon::internal_angle_radians(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn new(circumradius: f32, sides: u32) {
+        let output: Val<bevy::math::primitives::RegularPolygon> = bevy::math::primitives::RegularPolygon::new(
+                circumradius,
+                sides,
+            )
+            .into();
+        output
+    }
+    fn side_length(_self: Ref<bevy::math::primitives::RegularPolygon>) {
+        let output: f32 = bevy::math::primitives::RegularPolygon::side_length(&_self)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "rhombus")]
+impl bevy::math::primitives::Rhombus {
+    fn circumradius(_self: Ref<bevy::math::primitives::Rhombus>) {
+        let output: f32 = bevy::math::primitives::Rhombus::circumradius(&_self).into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::primitives::Rhombus>) {
+        let output: Val<bevy::math::primitives::Rhombus> = <bevy::math::primitives::Rhombus as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn closest_point(
+        _self: Ref<bevy::math::primitives::Rhombus>,
+        point: Val<bevy::math::prelude::Vec2>,
+    ) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Rhombus::closest_point(
+                &_self,
+                point.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Rhombus>,
+        other: Ref<bevy::math::primitives::Rhombus>,
+    ) {
+        let output: bool = <bevy::math::primitives::Rhombus as std::cmp::PartialEq<
+            bevy::math::primitives::Rhombus,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_inradius(inradius: f32) {
+        let output: Val<bevy::math::primitives::Rhombus> = bevy::math::primitives::Rhombus::from_inradius(
+                inradius,
+            )
+            .into();
+        output
+    }
+    fn from_side(side: f32) {
+        let output: Val<bevy::math::primitives::Rhombus> = bevy::math::primitives::Rhombus::from_side(
+                side,
+            )
+            .into();
+        output
+    }
+    fn inradius(_self: Ref<bevy::math::primitives::Rhombus>) {
+        let output: f32 = bevy::math::primitives::Rhombus::inradius(&_self).into();
+        output
+    }
+    fn new(horizontal_diagonal: f32, vertical_diagonal: f32) {
+        let output: Val<bevy::math::primitives::Rhombus> = bevy::math::primitives::Rhombus::new(
+                horizontal_diagonal,
+                vertical_diagonal,
+            )
+            .into();
+        output
+    }
+    fn side(_self: Ref<bevy::math::primitives::Rhombus>) {
+        let output: f32 = bevy::math::primitives::Rhombus::side(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "segment_2_d")]
+impl bevy::math::primitives::Segment2d {
+    fn clone(_self: Ref<bevy::math::primitives::Segment2d>) {
+        let output: Val<bevy::math::primitives::Segment2d> = <bevy::math::primitives::Segment2d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Segment2d>,
+        other: Ref<bevy::math::primitives::Segment2d>,
+    ) {
+        let output: bool = <bevy::math::primitives::Segment2d as std::cmp::PartialEq<
+            bevy::math::primitives::Segment2d,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn new(direction: Val<bevy::math::prelude::Dir2>, length: f32) {
+        let output: Val<bevy::math::primitives::Segment2d> = bevy::math::primitives::Segment2d::new(
+                direction.into_inner(),
+                length,
+            )
+            .into();
+        output
+    }
+    fn point1(_self: Ref<bevy::math::primitives::Segment2d>) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Segment2d::point1(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn point2(_self: Ref<bevy::math::primitives::Segment2d>) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Segment2d::point2(
+                &_self,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "triangle_2_d")]
+impl bevy::math::primitives::Triangle2d {
+    fn clone(_self: Ref<bevy::math::primitives::Triangle2d>) {
+        let output: Val<bevy::math::primitives::Triangle2d> = <bevy::math::primitives::Triangle2d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Triangle2d>,
+        other: Ref<bevy::math::primitives::Triangle2d>,
+    ) {
+        let output: bool = <bevy::math::primitives::Triangle2d as std::cmp::PartialEq<
+            bevy::math::primitives::Triangle2d,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn is_acute(_self: Ref<bevy::math::primitives::Triangle2d>) {
+        let output: bool = bevy::math::primitives::Triangle2d::is_acute(&_self).into();
+        output
+    }
+    fn is_degenerate(_self: Ref<bevy::math::primitives::Triangle2d>) {
+        let output: bool = bevy::math::primitives::Triangle2d::is_degenerate(&_self)
+            .into();
+        output
+    }
+    fn is_obtuse(_self: Ref<bevy::math::primitives::Triangle2d>) {
+        let output: bool = bevy::math::primitives::Triangle2d::is_obtuse(&_self).into();
+        output
+    }
+    fn new(
+        a: Val<bevy::math::prelude::Vec2>,
+        b: Val<bevy::math::prelude::Vec2>,
+        c: Val<bevy::math::prelude::Vec2>,
+    ) {
+        let output: Val<bevy::math::primitives::Triangle2d> = bevy::math::primitives::Triangle2d::new(
+                a.into_inner(),
+                b.into_inner(),
+                c.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn reverse(mut _self: Mut<bevy::math::primitives::Triangle2d>) {
+        let output: () = bevy::math::primitives::Triangle2d::reverse(&mut _self).into();
+        output
+    }
+    fn reversed(_self: Val<bevy::math::primitives::Triangle2d>) {
+        let output: Val<bevy::math::primitives::Triangle2d> = bevy::math::primitives::Triangle2d::reversed(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "aabb_3_d")]
+impl bevy::math::bounding::Aabb3d {
+    fn bounding_sphere(_self: Ref<bevy::math::bounding::Aabb3d>) {
+        let output: Val<bevy::math::bounding::BoundingSphere> = bevy::math::bounding::Aabb3d::bounding_sphere(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::bounding::Aabb3d>) {
+        let output: Val<bevy::math::bounding::Aabb3d> = <bevy::math::bounding::Aabb3d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "bounding_sphere")]
+impl bevy::math::bounding::BoundingSphere {
+    fn aabb_3d(_self: Ref<bevy::math::bounding::BoundingSphere>) {
+        let output: Val<bevy::math::bounding::Aabb3d> = bevy::math::bounding::BoundingSphere::aabb_3d(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::bounding::BoundingSphere>) {
+        let output: Val<bevy::math::bounding::BoundingSphere> = <bevy::math::bounding::BoundingSphere as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn radius(_self: Ref<bevy::math::bounding::BoundingSphere>) {
+        let output: f32 = bevy::math::bounding::BoundingSphere::radius(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "sphere")]
+impl bevy::math::primitives::Sphere {
+    fn clone(_self: Ref<bevy::math::primitives::Sphere>) {
+        let output: Val<bevy::math::primitives::Sphere> = <bevy::math::primitives::Sphere as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn closest_point(
+        _self: Ref<bevy::math::primitives::Sphere>,
+        point: Val<bevy::math::prelude::Vec3>,
+    ) {
+        let output: Val<bevy::math::prelude::Vec3> = bevy::math::primitives::Sphere::closest_point(
+                &_self,
+                point.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn diameter(_self: Ref<bevy::math::primitives::Sphere>) {
+        let output: f32 = bevy::math::primitives::Sphere::diameter(&_self).into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Sphere>,
+        other: Ref<bevy::math::primitives::Sphere>,
+    ) {
+        let output: bool = <bevy::math::primitives::Sphere as std::cmp::PartialEq<
+            bevy::math::primitives::Sphere,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn new(radius: f32) {
+        let output: Val<bevy::math::primitives::Sphere> = bevy::math::primitives::Sphere::new(
+                radius,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "cuboid")]
+impl bevy::math::primitives::Cuboid {
+    fn clone(_self: Ref<bevy::math::primitives::Cuboid>) {
+        let output: Val<bevy::math::primitives::Cuboid> = <bevy::math::primitives::Cuboid as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn closest_point(
+        _self: Ref<bevy::math::primitives::Cuboid>,
+        point: Val<bevy::math::prelude::Vec3>,
+    ) {
+        let output: Val<bevy::math::prelude::Vec3> = bevy::math::primitives::Cuboid::closest_point(
+                &_self,
+                point.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Cuboid>,
+        other: Ref<bevy::math::primitives::Cuboid>,
+    ) {
+        let output: bool = <bevy::math::primitives::Cuboid as std::cmp::PartialEq<
+            bevy::math::primitives::Cuboid,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_corners(
+        point1: Val<bevy::math::prelude::Vec3>,
+        point2: Val<bevy::math::prelude::Vec3>,
+    ) {
+        let output: Val<bevy::math::primitives::Cuboid> = bevy::math::primitives::Cuboid::from_corners(
+                point1.into_inner(),
+                point2.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_length(length: f32) {
+        let output: Val<bevy::math::primitives::Cuboid> = bevy::math::primitives::Cuboid::from_length(
+                length,
+            )
+            .into();
+        output
+    }
+    fn from_size(size: Val<bevy::math::prelude::Vec3>) {
+        let output: Val<bevy::math::primitives::Cuboid> = bevy::math::primitives::Cuboid::from_size(
+                size.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(x_length: f32, y_length: f32, z_length: f32) {
+        let output: Val<bevy::math::primitives::Cuboid> = bevy::math::primitives::Cuboid::new(
+                x_length,
+                y_length,
+                z_length,
+            )
+            .into();
+        output
+    }
+    fn size(_self: Ref<bevy::math::primitives::Cuboid>) {
+        let output: Val<bevy::math::prelude::Vec3> = bevy::math::primitives::Cuboid::size(
+                &_self,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "cylinder")]
+impl bevy::math::primitives::Cylinder {
+    fn base(_self: Ref<bevy::math::primitives::Cylinder>) {
+        let output: Val<bevy::math::primitives::Circle> = bevy::math::primitives::Cylinder::base(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn base_area(_self: Ref<bevy::math::primitives::Cylinder>) {
+        let output: f32 = bevy::math::primitives::Cylinder::base_area(&_self).into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::primitives::Cylinder>) {
+        let output: Val<bevy::math::primitives::Cylinder> = <bevy::math::primitives::Cylinder as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Cylinder>,
+        other: Ref<bevy::math::primitives::Cylinder>,
+    ) {
+        let output: bool = <bevy::math::primitives::Cylinder as std::cmp::PartialEq<
+            bevy::math::primitives::Cylinder,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn lateral_area(_self: Ref<bevy::math::primitives::Cylinder>) {
+        let output: f32 = bevy::math::primitives::Cylinder::lateral_area(&_self).into();
+        output
+    }
+    fn new(radius: f32, height: f32) {
+        let output: Val<bevy::math::primitives::Cylinder> = bevy::math::primitives::Cylinder::new(
+                radius,
+                height,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "capsule_3_d")]
+impl bevy::math::primitives::Capsule3d {
+    fn clone(_self: Ref<bevy::math::primitives::Capsule3d>) {
+        let output: Val<bevy::math::primitives::Capsule3d> = <bevy::math::primitives::Capsule3d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Capsule3d>,
+        other: Ref<bevy::math::primitives::Capsule3d>,
+    ) {
+        let output: bool = <bevy::math::primitives::Capsule3d as std::cmp::PartialEq<
+            bevy::math::primitives::Capsule3d,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn new(radius: f32, length: f32) {
+        let output: Val<bevy::math::primitives::Capsule3d> = bevy::math::primitives::Capsule3d::new(
+                radius,
+                length,
+            )
+            .into();
+        output
+    }
+    fn to_cylinder(_self: Ref<bevy::math::primitives::Capsule3d>) {
+        let output: Val<bevy::math::primitives::Cylinder> = bevy::math::primitives::Capsule3d::to_cylinder(
+                &_self,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "cone")]
+impl bevy::math::primitives::Cone {
+    fn base(_self: Ref<bevy::math::primitives::Cone>) {
+        let output: Val<bevy::math::primitives::Circle> = bevy::math::primitives::Cone::base(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn base_area(_self: Ref<bevy::math::primitives::Cone>) {
+        let output: f32 = bevy::math::primitives::Cone::base_area(&_self).into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::primitives::Cone>) {
+        let output: Val<bevy::math::primitives::Cone> = <bevy::math::primitives::Cone as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Cone>,
+        other: Ref<bevy::math::primitives::Cone>,
+    ) {
+        let output: bool = <bevy::math::primitives::Cone as std::cmp::PartialEq<
+            bevy::math::primitives::Cone,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn lateral_area(_self: Ref<bevy::math::primitives::Cone>) {
+        let output: f32 = bevy::math::primitives::Cone::lateral_area(&_self).into();
+        output
+    }
+    fn new(radius: f32, height: f32) {
+        let output: Val<bevy::math::primitives::Cone> = bevy::math::primitives::Cone::new(
+                radius,
+                height,
+            )
+            .into();
+        output
+    }
+    fn slant_height(_self: Ref<bevy::math::primitives::Cone>) {
+        let output: f32 = bevy::math::primitives::Cone::slant_height(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "conical_frustum")]
+impl bevy::math::primitives::ConicalFrustum {
+    fn clone(_self: Ref<bevy::math::primitives::ConicalFrustum>) {
+        let output: Val<bevy::math::primitives::ConicalFrustum> = <bevy::math::primitives::ConicalFrustum as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::ConicalFrustum>,
+        other: Ref<bevy::math::primitives::ConicalFrustum>,
+    ) {
+        let output: bool = <bevy::math::primitives::ConicalFrustum as std::cmp::PartialEq<
+            bevy::math::primitives::ConicalFrustum,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "infinite_plane_3_d")]
+impl bevy::math::primitives::InfinitePlane3d {
+    fn clone(_self: Ref<bevy::math::primitives::InfinitePlane3d>) {
+        let output: Val<bevy::math::primitives::InfinitePlane3d> = <bevy::math::primitives::InfinitePlane3d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::InfinitePlane3d>,
+        other: Ref<bevy::math::primitives::InfinitePlane3d>,
+    ) {
+        let output: bool = <bevy::math::primitives::InfinitePlane3d as std::cmp::PartialEq<
+            bevy::math::primitives::InfinitePlane3d,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn isometry_from_xy(
+        _self: Ref<bevy::math::primitives::InfinitePlane3d>,
+        origin: Val<bevy::math::prelude::Vec3>,
+    ) {
+        let output: Val<bevy::math::Isometry3d> = bevy::math::primitives::InfinitePlane3d::isometry_from_xy(
+                &_self,
+                origin.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn isometry_into_xy(
+        _self: Ref<bevy::math::primitives::InfinitePlane3d>,
+        origin: Val<bevy::math::prelude::Vec3>,
+    ) {
+        let output: Val<bevy::math::Isometry3d> = bevy::math::primitives::InfinitePlane3d::isometry_into_xy(
+                &_self,
+                origin.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "line_3_d")]
+impl bevy::math::primitives::Line3d {
+    fn clone(_self: Ref<bevy::math::primitives::Line3d>) {
+        let output: Val<bevy::math::primitives::Line3d> = <bevy::math::primitives::Line3d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Line3d>,
+        other: Ref<bevy::math::primitives::Line3d>,
+    ) {
+        let output: bool = <bevy::math::primitives::Line3d as std::cmp::PartialEq<
+            bevy::math::primitives::Line3d,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "segment_3_d")]
+impl bevy::math::primitives::Segment3d {
+    fn clone(_self: Ref<bevy::math::primitives::Segment3d>) {
+        let output: Val<bevy::math::primitives::Segment3d> = <bevy::math::primitives::Segment3d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Segment3d>,
+        other: Ref<bevy::math::primitives::Segment3d>,
+    ) {
+        let output: bool = <bevy::math::primitives::Segment3d as std::cmp::PartialEq<
+            bevy::math::primitives::Segment3d,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn new(direction: Val<bevy::math::prelude::Dir3>, length: f32) {
+        let output: Val<bevy::math::primitives::Segment3d> = bevy::math::primitives::Segment3d::new(
+                direction.into_inner(),
+                length,
+            )
+            .into();
+        output
+    }
+    fn point1(_self: Ref<bevy::math::primitives::Segment3d>) {
+        let output: Val<bevy::math::prelude::Vec3> = bevy::math::primitives::Segment3d::point1(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn point2(_self: Ref<bevy::math::primitives::Segment3d>) {
+        let output: Val<bevy::math::prelude::Vec3> = bevy::math::primitives::Segment3d::point2(
+                &_self,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "torus")]
+impl bevy::math::primitives::Torus {
+    fn clone(_self: Ref<bevy::math::primitives::Torus>) {
+        let output: Val<bevy::math::primitives::Torus> = <bevy::math::primitives::Torus as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Torus>,
+        other: Ref<bevy::math::primitives::Torus>,
+    ) {
+        let output: bool = <bevy::math::primitives::Torus as std::cmp::PartialEq<
+            bevy::math::primitives::Torus,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn inner_radius(_self: Ref<bevy::math::primitives::Torus>) {
+        let output: f32 = bevy::math::primitives::Torus::inner_radius(&_self).into();
+        output
+    }
+    fn new(inner_radius: f32, outer_radius: f32) {
+        let output: Val<bevy::math::primitives::Torus> = bevy::math::primitives::Torus::new(
+                inner_radius,
+                outer_radius,
+            )
+            .into();
+        output
+    }
+    fn outer_radius(_self: Ref<bevy::math::primitives::Torus>) {
+        let output: f32 = bevy::math::primitives::Torus::outer_radius(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "triangle_3_d")]
+impl bevy::math::primitives::Triangle3d {
+    fn centroid(_self: Ref<bevy::math::primitives::Triangle3d>) {
+        let output: Val<bevy::math::prelude::Vec3> = bevy::math::primitives::Triangle3d::centroid(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn circumcenter(_self: Ref<bevy::math::primitives::Triangle3d>) {
+        let output: Val<bevy::math::prelude::Vec3> = bevy::math::primitives::Triangle3d::circumcenter(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::primitives::Triangle3d>) {
+        let output: Val<bevy::math::primitives::Triangle3d> = <bevy::math::primitives::Triangle3d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Triangle3d>,
+        other: Ref<bevy::math::primitives::Triangle3d>,
+    ) {
+        let output: bool = <bevy::math::primitives::Triangle3d as std::cmp::PartialEq<
+            bevy::math::primitives::Triangle3d,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn is_acute(_self: Ref<bevy::math::primitives::Triangle3d>) {
+        let output: bool = bevy::math::primitives::Triangle3d::is_acute(&_self).into();
+        output
+    }
+    fn is_degenerate(_self: Ref<bevy::math::primitives::Triangle3d>) {
+        let output: bool = bevy::math::primitives::Triangle3d::is_degenerate(&_self)
+            .into();
+        output
+    }
+    fn is_obtuse(_self: Ref<bevy::math::primitives::Triangle3d>) {
+        let output: bool = bevy::math::primitives::Triangle3d::is_obtuse(&_self).into();
+        output
+    }
+    fn new(
+        a: Val<bevy::math::prelude::Vec3>,
+        b: Val<bevy::math::prelude::Vec3>,
+        c: Val<bevy::math::prelude::Vec3>,
+    ) {
+        let output: Val<bevy::math::primitives::Triangle3d> = bevy::math::primitives::Triangle3d::new(
+                a.into_inner(),
+                b.into_inner(),
+                c.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn reverse(mut _self: Mut<bevy::math::primitives::Triangle3d>) {
+        let output: () = bevy::math::primitives::Triangle3d::reverse(&mut _self).into();
+        output
+    }
+    fn reversed(_self: Val<bevy::math::primitives::Triangle3d>) {
+        let output: Val<bevy::math::primitives::Triangle3d> = bevy::math::primitives::Triangle3d::reversed(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "ray_cast_2_d")]
+impl bevy::math::bounding::RayCast2d {
+    fn aabb_intersection_at(
+        _self: Ref<bevy::math::bounding::RayCast2d>,
+        aabb: Ref<bevy::math::bounding::Aabb2d>,
+    ) {
+        let output: std::option::Option<f32> = bevy::math::bounding::RayCast2d::aabb_intersection_at(
+                &_self,
+                &aabb,
+            )
+            .into();
+        output
+    }
+    fn circle_intersection_at(
+        _self: Ref<bevy::math::bounding::RayCast2d>,
+        circle: Ref<bevy::math::bounding::BoundingCircle>,
+    ) {
+        let output: std::option::Option<f32> = bevy::math::bounding::RayCast2d::circle_intersection_at(
+                &_self,
+                &circle,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::bounding::RayCast2d>) {
+        let output: Val<bevy::math::bounding::RayCast2d> = <bevy::math::bounding::RayCast2d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn direction_recip(_self: Ref<bevy::math::bounding::RayCast2d>) {
+        let output: Val<bevy::math::prelude::Vec2> = bevy::math::bounding::RayCast2d::direction_recip(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn from_ray(ray: Val<bevy::math::Ray2d>, max: f32) {
+        let output: Val<bevy::math::bounding::RayCast2d> = bevy::math::bounding::RayCast2d::from_ray(
+                ray.into_inner(),
+                max,
+            )
+            .into();
+        output
+    }
+    fn new(
+        origin: Val<bevy::math::prelude::Vec2>,
+        direction: Val<bevy::math::prelude::Dir2>,
+        max: f32,
+    ) {
+        let output: Val<bevy::math::bounding::RayCast2d> = bevy::math::bounding::RayCast2d::new(
+                origin.into_inner(),
+                direction.into_inner(),
+                max,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "aabb_cast_2_d")]
+impl bevy::math::bounding::AabbCast2d {
+    fn aabb_collision_at(
+        _self: Ref<bevy::math::bounding::AabbCast2d>,
+        aabb: Val<bevy::math::bounding::Aabb2d>,
+    ) {
+        let output: std::option::Option<f32> = bevy::math::bounding::AabbCast2d::aabb_collision_at(
+                &_self,
+                aabb.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::bounding::AabbCast2d>) {
+        let output: Val<bevy::math::bounding::AabbCast2d> = <bevy::math::bounding::AabbCast2d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn from_ray(
+        aabb: Val<bevy::math::bounding::Aabb2d>,
+        ray: Val<bevy::math::Ray2d>,
+        max: f32,
+    ) {
+        let output: Val<bevy::math::bounding::AabbCast2d> = bevy::math::bounding::AabbCast2d::from_ray(
+                aabb.into_inner(),
+                ray.into_inner(),
+                max,
+            )
+            .into();
+        output
+    }
+    fn new(
+        aabb: Val<bevy::math::bounding::Aabb2d>,
+        origin: Val<bevy::math::prelude::Vec2>,
+        direction: Val<bevy::math::prelude::Dir2>,
+        max: f32,
+    ) {
+        let output: Val<bevy::math::bounding::AabbCast2d> = bevy::math::bounding::AabbCast2d::new(
+                aabb.into_inner(),
+                origin.into_inner(),
+                direction.into_inner(),
+                max,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "bounding_circle_cast")]
+impl bevy::math::bounding::BoundingCircleCast {
+    fn circle_collision_at(
+        _self: Ref<bevy::math::bounding::BoundingCircleCast>,
+        circle: Val<bevy::math::bounding::BoundingCircle>,
+    ) {
+        let output: std::option::Option<f32> = bevy::math::bounding::BoundingCircleCast::circle_collision_at(
+                &_self,
+                circle.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::bounding::BoundingCircleCast>) {
+        let output: Val<bevy::math::bounding::BoundingCircleCast> = <bevy::math::bounding::BoundingCircleCast as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn from_ray(
+        circle: Val<bevy::math::bounding::BoundingCircle>,
+        ray: Val<bevy::math::Ray2d>,
+        max: f32,
+    ) {
+        let output: Val<bevy::math::bounding::BoundingCircleCast> = bevy::math::bounding::BoundingCircleCast::from_ray(
+                circle.into_inner(),
+                ray.into_inner(),
+                max,
+            )
+            .into();
+        output
+    }
+    fn new(
+        circle: Val<bevy::math::bounding::BoundingCircle>,
+        origin: Val<bevy::math::prelude::Vec2>,
+        direction: Val<bevy::math::prelude::Dir2>,
+        max: f32,
+    ) {
+        let output: Val<bevy::math::bounding::BoundingCircleCast> = bevy::math::bounding::BoundingCircleCast::new(
+                circle.into_inner(),
+                origin.into_inner(),
+                direction.into_inner(),
+                max,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "ray_cast_3_d")]
+impl bevy::math::bounding::RayCast3d {
+    fn aabb_intersection_at(
+        _self: Ref<bevy::math::bounding::RayCast3d>,
+        aabb: Ref<bevy::math::bounding::Aabb3d>,
+    ) {
+        let output: std::option::Option<f32> = bevy::math::bounding::RayCast3d::aabb_intersection_at(
+                &_self,
+                &aabb,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::bounding::RayCast3d>) {
+        let output: Val<bevy::math::bounding::RayCast3d> = <bevy::math::bounding::RayCast3d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn direction_recip(_self: Ref<bevy::math::bounding::RayCast3d>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::bounding::RayCast3d::direction_recip(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn from_ray(ray: Val<bevy::math::Ray3d>, max: f32) {
+        let output: Val<bevy::math::bounding::RayCast3d> = bevy::math::bounding::RayCast3d::from_ray(
+                ray.into_inner(),
+                max,
+            )
+            .into();
+        output
+    }
+    fn sphere_intersection_at(
+        _self: Ref<bevy::math::bounding::RayCast3d>,
+        sphere: Ref<bevy::math::bounding::BoundingSphere>,
+    ) {
+        let output: std::option::Option<f32> = bevy::math::bounding::RayCast3d::sphere_intersection_at(
+                &_self,
+                &sphere,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "aabb_cast_3_d")]
+impl bevy::math::bounding::AabbCast3d {
+    fn aabb_collision_at(
+        _self: Ref<bevy::math::bounding::AabbCast3d>,
+        aabb: Val<bevy::math::bounding::Aabb3d>,
+    ) {
+        let output: std::option::Option<f32> = bevy::math::bounding::AabbCast3d::aabb_collision_at(
+                &_self,
+                aabb.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::bounding::AabbCast3d>) {
+        let output: Val<bevy::math::bounding::AabbCast3d> = <bevy::math::bounding::AabbCast3d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn from_ray(
+        aabb: Val<bevy::math::bounding::Aabb3d>,
+        ray: Val<bevy::math::Ray3d>,
+        max: f32,
+    ) {
+        let output: Val<bevy::math::bounding::AabbCast3d> = bevy::math::bounding::AabbCast3d::from_ray(
+                aabb.into_inner(),
+                ray.into_inner(),
+                max,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "bounding_sphere_cast")]
+impl bevy::math::bounding::BoundingSphereCast {
+    fn clone(_self: Ref<bevy::math::bounding::BoundingSphereCast>) {
+        let output: Val<bevy::math::bounding::BoundingSphereCast> = <bevy::math::bounding::BoundingSphereCast as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn from_ray(
+        sphere: Val<bevy::math::bounding::BoundingSphere>,
+        ray: Val<bevy::math::Ray3d>,
+        max: f32,
+    ) {
+        let output: Val<bevy::math::bounding::BoundingSphereCast> = bevy::math::bounding::BoundingSphereCast::from_ray(
+                sphere.into_inner(),
+                ray.into_inner(),
+                max,
+            )
+            .into();
+        output
+    }
+    fn sphere_collision_at(
+        _self: Ref<bevy::math::bounding::BoundingSphereCast>,
+        sphere: Val<bevy::math::bounding::BoundingSphere>,
+    ) {
+        let output: std::option::Option<f32> = bevy::math::bounding::BoundingSphereCast::sphere_collision_at(
+                &_self,
+                sphere.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "interval")]
+impl bevy::math::curve::interval::Interval {
+    fn clamp(_self: Val<bevy::math::curve::interval::Interval>, value: f32) {
+        let output: f32 = bevy::math::curve::interval::Interval::clamp(
+                _self.into_inner(),
+                value,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::curve::interval::Interval>) {
+        let output: Val<bevy::math::curve::interval::Interval> = <bevy::math::curve::interval::Interval as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn contains(_self: Val<bevy::math::curve::interval::Interval>, item: f32) {
+        let output: bool = bevy::math::curve::interval::Interval::contains(
+                _self.into_inner(),
+                item,
+            )
+            .into();
+        output
+    }
+    fn contains_interval(
+        _self: Val<bevy::math::curve::interval::Interval>,
+        other: Val<bevy::math::curve::interval::Interval>,
+    ) {
+        let output: bool = bevy::math::curve::interval::Interval::contains_interval(
+                _self.into_inner(),
+                other.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn end(_self: Val<bevy::math::curve::interval::Interval>) {
+        let output: f32 = bevy::math::curve::interval::Interval::end(_self.into_inner())
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::curve::interval::Interval>,
+        other: Ref<bevy::math::curve::interval::Interval>,
+    ) {
+        let output: bool = <bevy::math::curve::interval::Interval as std::cmp::PartialEq<
+            bevy::math::curve::interval::Interval,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn has_finite_end(_self: Val<bevy::math::curve::interval::Interval>) {
+        let output: bool = bevy::math::curve::interval::Interval::has_finite_end(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn has_finite_start(_self: Val<bevy::math::curve::interval::Interval>) {
+        let output: bool = bevy::math::curve::interval::Interval::has_finite_start(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn is_bounded(_self: Val<bevy::math::curve::interval::Interval>) {
+        let output: bool = bevy::math::curve::interval::Interval::is_bounded(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn length(_self: Val<bevy::math::curve::interval::Interval>) {
+        let output: f32 = bevy::math::curve::interval::Interval::length(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn start(_self: Val<bevy::math::curve::interval::Interval>) {
+        let output: f32 = bevy::math::curve::interval::Interval::start(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "float_ord")]
+impl bevy::math::FloatOrd {
+    fn clone(_self: Ref<bevy::math::FloatOrd>) {
+        let output: Val<bevy::math::FloatOrd> = <bevy::math::FloatOrd as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::FloatOrd>, other: Ref<bevy::math::FloatOrd>) {
+        let output: bool = <bevy::math::FloatOrd as std::cmp::PartialEq<
+            bevy::math::FloatOrd,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn ge(_self: Ref<bevy::math::FloatOrd>, other: Ref<bevy::math::FloatOrd>) {
+        let output: bool = <bevy::math::FloatOrd as std::cmp::PartialOrd<
+            bevy::math::FloatOrd,
+        >>::ge(&_self, &other)
+            .into();
+        output
+    }
+    fn gt(_self: Ref<bevy::math::FloatOrd>, other: Ref<bevy::math::FloatOrd>) {
+        let output: bool = <bevy::math::FloatOrd as std::cmp::PartialOrd<
+            bevy::math::FloatOrd,
+        >>::gt(&_self, &other)
+            .into();
+        output
+    }
+    fn le(_self: Ref<bevy::math::FloatOrd>, other: Ref<bevy::math::FloatOrd>) {
+        let output: bool = <bevy::math::FloatOrd as std::cmp::PartialOrd<
+            bevy::math::FloatOrd,
+        >>::le(&_self, &other)
+            .into();
+        output
+    }
+    fn lt(_self: Ref<bevy::math::FloatOrd>, other: Ref<bevy::math::FloatOrd>) {
+        let output: bool = <bevy::math::FloatOrd as std::cmp::PartialOrd<
+            bevy::math::FloatOrd,
+        >>::lt(&_self, &other)
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::FloatOrd>) {
+        let output: Val<bevy::math::FloatOrd> = <bevy::math::FloatOrd as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "plane_3_d")]
+impl bevy::math::primitives::Plane3d {
+    fn clone(_self: Ref<bevy::math::primitives::Plane3d>) {
+        let output: Val<bevy::math::primitives::Plane3d> = <bevy::math::primitives::Plane3d as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Plane3d>,
+        other: Ref<bevy::math::primitives::Plane3d>,
+    ) {
+        let output: bool = <bevy::math::primitives::Plane3d as std::cmp::PartialEq<
+            bevy::math::primitives::Plane3d,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn new(
+        normal: Val<bevy::math::prelude::Vec3>,
+        half_size: Val<bevy::math::prelude::Vec2>,
+    ) {
+        let output: Val<bevy::math::primitives::Plane3d> = bevy::math::primitives::Plane3d::new(
+                normal.into_inner(),
+                half_size.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "tetrahedron")]
+impl bevy::math::primitives::Tetrahedron {
+    fn centroid(_self: Ref<bevy::math::primitives::Tetrahedron>) {
+        let output: Val<bevy::math::prelude::Vec3> = bevy::math::primitives::Tetrahedron::centroid(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::primitives::Tetrahedron>) {
+        let output: Val<bevy::math::primitives::Tetrahedron> = <bevy::math::primitives::Tetrahedron as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::primitives::Tetrahedron>,
+        other: Ref<bevy::math::primitives::Tetrahedron>,
+    ) {
+        let output: bool = <bevy::math::primitives::Tetrahedron as std::cmp::PartialEq<
+            bevy::math::primitives::Tetrahedron,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn new(
+        a: Val<bevy::math::prelude::Vec3>,
+        b: Val<bevy::math::prelude::Vec3>,
+        c: Val<bevy::math::prelude::Vec3>,
+        d: Val<bevy::math::prelude::Vec3>,
+    ) {
+        let output: Val<bevy::math::primitives::Tetrahedron> = bevy::math::primitives::Tetrahedron::new(
+                a.into_inner(),
+                b.into_inner(),
+                c.into_inner(),
+                d.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn signed_volume(_self: Ref<bevy::math::primitives::Tetrahedron>) {
+        let output: f32 = bevy::math::primitives::Tetrahedron::signed_volume(&_self)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "ease_function")]
+impl bevy::math::curve::easing::EaseFunction {
+    fn clone(_self: Ref<bevy::math::curve::easing::EaseFunction>) {
+        let output: Val<bevy::math::curve::easing::EaseFunction> = <bevy::math::curve::easing::EaseFunction as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::math::curve::easing::EaseFunction>,
+        other: Ref<bevy::math::curve::easing::EaseFunction>,
+    ) {
+        let output: bool = <bevy::math::curve::easing::EaseFunction as std::cmp::PartialEq<
+            bevy::math::curve::easing::EaseFunction,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
 impl ::bevy::app::Plugin for BevyMathScriptingPlugin {
     fn build(&self, app: &mut ::bevy::prelude::App) {
         let mut world = app.world_mut();
-        NamespaceBuilder::<::bevy::math::AspectRatio>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::AspectRatio>| {
-                    let output: Val<bevy::math::AspectRatio> = <bevy::math::AspectRatio as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::AspectRatio>,
-                    other: Ref<bevy::math::AspectRatio>|
-                {
-                    let output: bool = <bevy::math::AspectRatio as std::cmp::PartialEq<
-                        bevy::math::AspectRatio,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse",
-                |_self: Ref<bevy::math::AspectRatio>| {
-                    let output: Val<bevy::math::AspectRatio> = bevy::math::AspectRatio::inverse(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_landscape",
-                |_self: Ref<bevy::math::AspectRatio>| {
-                    let output: bool = bevy::math::AspectRatio::is_landscape(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_portrait",
-                |_self: Ref<bevy::math::AspectRatio>| {
-                    let output: bool = bevy::math::AspectRatio::is_portrait(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_square",
-                |_self: Ref<bevy::math::AspectRatio>| {
-                    let output: bool = bevy::math::AspectRatio::is_square(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "ratio",
-                |_self: Ref<bevy::math::AspectRatio>| {
-                    let output: f32 = bevy::math::AspectRatio::ratio(&_self).into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::CompassOctant>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::CompassOctant>| {
-                    let output: () = <bevy::math::CompassOctant as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::CompassOctant>| {
-                    let output: Val<bevy::math::CompassOctant> = <bevy::math::CompassOctant as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::CompassOctant>,
-                    other: Ref<bevy::math::CompassOctant>|
-                {
-                    let output: bool = <bevy::math::CompassOctant as std::cmp::PartialEq<
-                        bevy::math::CompassOctant,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::CompassQuadrant>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::CompassQuadrant>| {
-                    let output: () = <bevy::math::CompassQuadrant as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::CompassQuadrant>| {
-                    let output: Val<bevy::math::CompassQuadrant> = <bevy::math::CompassQuadrant as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::CompassQuadrant>,
-                    other: Ref<bevy::math::CompassQuadrant>|
-                {
-                    let output: bool = <bevy::math::CompassQuadrant as std::cmp::PartialEq<
-                        bevy::math::CompassQuadrant,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::Isometry2d>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::Isometry2d>| {
-                    let output: Val<bevy::math::Isometry2d> = <bevy::math::Isometry2d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::Isometry2d>, other: Ref<bevy::math::Isometry2d>| {
-                    let output: bool = <bevy::math::Isometry2d as std::cmp::PartialEq<
-                        bevy::math::Isometry2d,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation",
-                |rotation: Val<bevy::math::Rot2>| {
-                    let output: Val<bevy::math::Isometry2d> = bevy::math::Isometry2d::from_rotation(
-                            rotation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_translation",
-                |translation: Val<bevy::math::prelude::Vec2>| {
-                    let output: Val<bevy::math::Isometry2d> = bevy::math::Isometry2d::from_translation(
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_xy",
-                |x: f32, y: f32| {
-                    let output: Val<bevy::math::Isometry2d> = bevy::math::Isometry2d::from_xy(
-                            x,
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse",
-                |_self: Ref<bevy::math::Isometry2d>| {
-                    let output: Val<bevy::math::Isometry2d> = bevy::math::Isometry2d::inverse(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse_mul",
-                |_self: Ref<bevy::math::Isometry2d>, rhs: Val<bevy::math::Isometry2d>| {
-                    let output: Val<bevy::math::Isometry2d> = bevy::math::Isometry2d::inverse_mul(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse_transform_point",
-                |
-                    _self: Ref<bevy::math::Isometry2d>,
-                    point: Val<bevy::math::prelude::Vec2>|
-                {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::Isometry2d::inverse_transform_point(
-                            &_self,
-                            point.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Isometry2d>, rhs: Val<bevy::math::Isometry2d>| {
-                    let output: Val<bevy::math::Isometry2d> = <bevy::math::Isometry2d as std::ops::Mul<
-                        bevy::math::Isometry2d,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |
-                    _self: Val<bevy::math::Isometry2d>,
-                    rhs: Val<bevy::math::prelude::Dir2>|
-                {
-                    let output: Val<bevy::math::prelude::Dir2> = <bevy::math::Isometry2d as std::ops::Mul<
-                        bevy::math::prelude::Dir2,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |
-                    _self: Val<bevy::math::Isometry2d>,
-                    rhs: Val<bevy::math::prelude::Vec2>|
-                {
-                    let output: Val<bevy::math::prelude::Vec2> = <bevy::math::Isometry2d as std::ops::Mul<
-                        bevy::math::prelude::Vec2,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |
-                    translation: Val<bevy::math::prelude::Vec2>,
-                    rotation: Val<bevy::math::Rot2>|
-                {
-                    let output: Val<bevy::math::Isometry2d> = bevy::math::Isometry2d::new(
-                            translation.into_inner(),
-                            rotation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_point",
-                |
-                    _self: Ref<bevy::math::Isometry2d>,
-                    point: Val<bevy::math::prelude::Vec2>|
-                {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::Isometry2d::transform_point(
-                            &_self,
-                            point.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::Isometry3d>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::Isometry3d>| {
-                    let output: Val<bevy::math::Isometry3d> = <bevy::math::Isometry3d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::Isometry3d>, other: Ref<bevy::math::Isometry3d>| {
-                    let output: bool = <bevy::math::Isometry3d as std::cmp::PartialEq<
-                        bevy::math::Isometry3d,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation",
-                |rotation: Val<bevy::math::prelude::Quat>| {
-                    let output: Val<bevy::math::Isometry3d> = bevy::math::Isometry3d::from_rotation(
-                            rotation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_xyz",
-                |x: f32, y: f32, z: f32| {
-                    let output: Val<bevy::math::Isometry3d> = bevy::math::Isometry3d::from_xyz(
-                            x,
-                            y,
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse",
-                |_self: Ref<bevy::math::Isometry3d>| {
-                    let output: Val<bevy::math::Isometry3d> = bevy::math::Isometry3d::inverse(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse_mul",
-                |_self: Ref<bevy::math::Isometry3d>, rhs: Val<bevy::math::Isometry3d>| {
-                    let output: Val<bevy::math::Isometry3d> = bevy::math::Isometry3d::inverse_mul(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Isometry3d>, rhs: Val<bevy::math::Isometry3d>| {
-                    let output: Val<bevy::math::Isometry3d> = <bevy::math::Isometry3d as std::ops::Mul<
-                        bevy::math::Isometry3d,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Isometry3d>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Isometry3d as std::ops::Mul<
-                        bevy::math::Vec3A,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |
-                    _self: Val<bevy::math::Isometry3d>,
-                    rhs: Val<bevy::math::prelude::Dir3>|
-                {
-                    let output: Val<bevy::math::prelude::Dir3> = <bevy::math::Isometry3d as std::ops::Mul<
-                        bevy::math::prelude::Dir3,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |
-                    _self: Val<bevy::math::Isometry3d>,
-                    rhs: Val<bevy::math::prelude::Vec3>|
-                {
-                    let output: Val<bevy::math::prelude::Vec3> = <bevy::math::Isometry3d as std::ops::Mul<
-                        bevy::math::prelude::Vec3,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::Ray2d>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::Ray2d>| {
-                    let output: Val<bevy::math::Ray2d> = <bevy::math::Ray2d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::Ray2d>, other: Ref<bevy::math::Ray2d>| {
-                    let output: bool = <bevy::math::Ray2d as std::cmp::PartialEq<
-                        bevy::math::Ray2d,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "get_point",
-                |_self: Ref<bevy::math::Ray2d>, distance: f32| {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::Ray2d::get_point(
-                            &_self,
-                            distance,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "intersect_plane",
-                |
-                    _self: Ref<bevy::math::Ray2d>,
-                    plane_origin: Val<bevy::math::prelude::Vec2>,
-                    plane: Val<bevy::math::primitives::Plane2d>|
-                {
-                    let output: std::option::Option<f32> = bevy::math::Ray2d::intersect_plane(
-                            &_self,
-                            plane_origin.into_inner(),
-                            plane.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |
-                    origin: Val<bevy::math::prelude::Vec2>,
-                    direction: Val<bevy::math::prelude::Dir2>|
-                {
-                    let output: Val<bevy::math::Ray2d> = bevy::math::Ray2d::new(
-                            origin.into_inner(),
-                            direction.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::Ray3d>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::Ray3d>| {
-                    let output: Val<bevy::math::Ray3d> = <bevy::math::Ray3d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::Ray3d>, other: Ref<bevy::math::Ray3d>| {
-                    let output: bool = <bevy::math::Ray3d as std::cmp::PartialEq<
-                        bevy::math::Ray3d,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "get_point",
-                |_self: Ref<bevy::math::Ray3d>, distance: f32| {
-                    let output: Val<bevy::math::prelude::Vec3> = bevy::math::Ray3d::get_point(
-                            &_self,
-                            distance,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "intersect_plane",
-                |
-                    _self: Ref<bevy::math::Ray3d>,
-                    plane_origin: Val<bevy::math::prelude::Vec3>,
-                    plane: Val<bevy::math::primitives::InfinitePlane3d>|
-                {
-                    let output: std::option::Option<f32> = bevy::math::Ray3d::intersect_plane(
-                            &_self,
-                            plane_origin.into_inner(),
-                            plane.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |
-                    origin: Val<bevy::math::prelude::Vec3>,
-                    direction: Val<bevy::math::prelude::Dir3>|
-                {
-                    let output: Val<bevy::math::Ray3d> = bevy::math::Ray3d::new(
-                            origin.into_inner(),
-                            direction.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::Rot2>::new(world)
-            .register(
-                "angle_between",
-                |_self: Val<bevy::math::Rot2>, other: Val<bevy::math::Rot2>| {
-                    let output: f32 = bevy::math::Rot2::angle_between(
-                            _self.into_inner(),
-                            other.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "angle_to",
-                |_self: Val<bevy::math::Rot2>, other: Val<bevy::math::Rot2>| {
-                    let output: f32 = bevy::math::Rot2::angle_to(
-                            _self.into_inner(),
-                            other.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_degrees",
-                |_self: Val<bevy::math::Rot2>| {
-                    let output: f32 = bevy::math::Rot2::as_degrees(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_radians",
-                |_self: Val<bevy::math::Rot2>| {
-                    let output: f32 = bevy::math::Rot2::as_radians(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_turn_fraction",
-                |_self: Val<bevy::math::Rot2>| {
-                    let output: f32 = bevy::math::Rot2::as_turn_fraction(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::Rot2>| {
-                    let output: Val<bevy::math::Rot2> = <bevy::math::Rot2 as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "degrees",
-                |degrees: f32| {
-                    let output: Val<bevy::math::Rot2> = bevy::math::Rot2::degrees(
-                            degrees,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::Rot2>, other: Ref<bevy::math::Rot2>| {
-                    let output: bool = <bevy::math::Rot2 as std::cmp::PartialEq<
-                        bevy::math::Rot2,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fast_renormalize",
-                |_self: Val<bevy::math::Rot2>| {
-                    let output: Val<bevy::math::Rot2> = bevy::math::Rot2::fast_renormalize(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_sin_cos",
-                |sin: f32, cos: f32| {
-                    let output: Val<bevy::math::Rot2> = bevy::math::Rot2::from_sin_cos(
-                            sin,
-                            cos,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse",
-                |_self: Val<bevy::math::Rot2>| {
-                    let output: Val<bevy::math::Rot2> = bevy::math::Rot2::inverse(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Val<bevy::math::Rot2>| {
-                    let output: bool = bevy::math::Rot2::is_finite(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Val<bevy::math::Rot2>| {
-                    let output: bool = bevy::math::Rot2::is_nan(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_near_identity",
-                |_self: Val<bevy::math::Rot2>| {
-                    let output: bool = bevy::math::Rot2::is_near_identity(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_normalized",
-                |_self: Val<bevy::math::Rot2>| {
-                    let output: bool = bevy::math::Rot2::is_normalized(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length",
-                |_self: Val<bevy::math::Rot2>| {
-                    let output: f32 = bevy::math::Rot2::length(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_recip",
-                |_self: Val<bevy::math::Rot2>| {
-                    let output: f32 = bevy::math::Rot2::length_recip(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::Rot2>| {
-                    let output: f32 = bevy::math::Rot2::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Rot2>, rhs: Val<bevy::math::Rot2>| {
-                    let output: Val<bevy::math::Rot2> = <bevy::math::Rot2 as std::ops::Mul<
-                        bevy::math::Rot2,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |
-                    _self: Val<bevy::math::Rot2>,
-                    direction: Val<bevy::math::prelude::Dir2>|
-                {
-                    let output: Val<bevy::math::prelude::Dir2> = <bevy::math::Rot2 as std::ops::Mul<
-                        bevy::math::prelude::Dir2,
-                    >>::mul(_self.into_inner(), direction.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Rot2>, rhs: Val<bevy::math::prelude::Vec2>| {
-                    let output: Val<bevy::math::prelude::Vec2> = <bevy::math::Rot2 as std::ops::Mul<
-                        bevy::math::prelude::Vec2,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "nlerp",
-                |_self: Val<bevy::math::Rot2>, end: Val<bevy::math::Rot2>, s: f32| {
-                    let output: Val<bevy::math::Rot2> = bevy::math::Rot2::nlerp(
-                            _self.into_inner(),
-                            end.into_inner(),
-                            s,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize",
-                |_self: Val<bevy::math::Rot2>| {
-                    let output: Val<bevy::math::Rot2> = bevy::math::Rot2::normalize(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "radians",
-                |radians: f32| {
-                    let output: Val<bevy::math::Rot2> = bevy::math::Rot2::radians(
-                            radians,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sin_cos",
-                |_self: Val<bevy::math::Rot2>| {
-                    let output: (f32, f32) = bevy::math::Rot2::sin_cos(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "slerp",
-                |_self: Val<bevy::math::Rot2>, end: Val<bevy::math::Rot2>, s: f32| {
-                    let output: Val<bevy::math::Rot2> = bevy::math::Rot2::slerp(
-                            _self.into_inner(),
-                            end.into_inner(),
-                            s,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "turn_fraction",
-                |fraction: f32| {
-                    let output: Val<bevy::math::Rot2> = bevy::math::Rot2::turn_fraction(
-                            fraction,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::prelude::Dir2>::new(world)
-            .register(
-                "as_vec2",
-                |_self: Ref<bevy::math::prelude::Dir2>| {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::prelude::Dir2::as_vec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::prelude::Dir2>| {
-                    let output: Val<bevy::math::prelude::Dir2> = <bevy::math::prelude::Dir2 as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::prelude::Dir2>,
-                    other: Ref<bevy::math::prelude::Dir2>|
-                {
-                    let output: bool = <bevy::math::prelude::Dir2 as std::cmp::PartialEq<
-                        bevy::math::prelude::Dir2,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fast_renormalize",
-                |_self: Val<bevy::math::prelude::Dir2>| {
-                    let output: Val<bevy::math::prelude::Dir2> = bevy::math::prelude::Dir2::fast_renormalize(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_xy_unchecked",
-                |x: f32, y: f32| {
-                    let output: Val<bevy::math::prelude::Dir2> = bevy::math::prelude::Dir2::from_xy_unchecked(
-                            x,
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::prelude::Dir2>, rhs: f32| {
-                    let output: Val<bevy::math::prelude::Vec2> = <bevy::math::prelude::Dir2 as std::ops::Mul<
-                        f32,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::prelude::Dir2>| {
-                    let output: Val<bevy::math::prelude::Dir2> = <bevy::math::prelude::Dir2 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new_unchecked",
-                |value: Val<bevy::math::prelude::Vec2>| {
-                    let output: Val<bevy::math::prelude::Dir2> = bevy::math::prelude::Dir2::new_unchecked(
-                            value.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotation_from",
-                |
-                    _self: Val<bevy::math::prelude::Dir2>,
-                    other: Val<bevy::math::prelude::Dir2>|
-                {
-                    let output: Val<bevy::math::Rot2> = bevy::math::prelude::Dir2::rotation_from(
-                            _self.into_inner(),
-                            other.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotation_from_x",
-                |_self: Val<bevy::math::prelude::Dir2>| {
-                    let output: Val<bevy::math::Rot2> = bevy::math::prelude::Dir2::rotation_from_x(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotation_from_y",
-                |_self: Val<bevy::math::prelude::Dir2>| {
-                    let output: Val<bevy::math::Rot2> = bevy::math::prelude::Dir2::rotation_from_y(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotation_to",
-                |
-                    _self: Val<bevy::math::prelude::Dir2>,
-                    other: Val<bevy::math::prelude::Dir2>|
-                {
-                    let output: Val<bevy::math::Rot2> = bevy::math::prelude::Dir2::rotation_to(
-                            _self.into_inner(),
-                            other.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotation_to_x",
-                |_self: Val<bevy::math::prelude::Dir2>| {
-                    let output: Val<bevy::math::Rot2> = bevy::math::prelude::Dir2::rotation_to_x(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotation_to_y",
-                |_self: Val<bevy::math::prelude::Dir2>| {
-                    let output: Val<bevy::math::Rot2> = bevy::math::prelude::Dir2::rotation_to_y(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "slerp",
-                |
-                    _self: Val<bevy::math::prelude::Dir2>,
-                    rhs: Val<bevy::math::prelude::Dir2>,
-                    s: f32|
-                {
-                    let output: Val<bevy::math::prelude::Dir2> = bevy::math::prelude::Dir2::slerp(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                            s,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::prelude::Dir3>::new(world)
-            .register(
-                "as_vec3",
-                |_self: Ref<bevy::math::prelude::Dir3>| {
-                    let output: Val<bevy::math::prelude::Vec3> = bevy::math::prelude::Dir3::as_vec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::prelude::Dir3>| {
-                    let output: Val<bevy::math::prelude::Dir3> = <bevy::math::prelude::Dir3 as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::prelude::Dir3>,
-                    other: Ref<bevy::math::prelude::Dir3>|
-                {
-                    let output: bool = <bevy::math::prelude::Dir3 as std::cmp::PartialEq<
-                        bevy::math::prelude::Dir3,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fast_renormalize",
-                |_self: Val<bevy::math::prelude::Dir3>| {
-                    let output: Val<bevy::math::prelude::Dir3> = bevy::math::prelude::Dir3::fast_renormalize(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_xyz_unchecked",
-                |x: f32, y: f32, z: f32| {
-                    let output: Val<bevy::math::prelude::Dir3> = bevy::math::prelude::Dir3::from_xyz_unchecked(
-                            x,
-                            y,
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::prelude::Dir3>, rhs: f32| {
-                    let output: Val<bevy::math::prelude::Vec3> = <bevy::math::prelude::Dir3 as std::ops::Mul<
-                        f32,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::prelude::Dir3>| {
-                    let output: Val<bevy::math::prelude::Dir3> = <bevy::math::prelude::Dir3 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new_unchecked",
-                |value: Val<bevy::math::prelude::Vec3>| {
-                    let output: Val<bevy::math::prelude::Dir3> = bevy::math::prelude::Dir3::new_unchecked(
-                            value.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "slerp",
-                |
-                    _self: Val<bevy::math::prelude::Dir3>,
-                    rhs: Val<bevy::math::prelude::Dir3>,
-                    s: f32|
-                {
-                    let output: Val<bevy::math::prelude::Dir3> = bevy::math::prelude::Dir3::slerp(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                            s,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::prelude::Dir3A>::new(world)
-            .register(
-                "as_vec3a",
-                |_self: Ref<bevy::math::prelude::Dir3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::prelude::Dir3A::as_vec3a(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::prelude::Dir3A>| {
-                    let output: Val<bevy::math::prelude::Dir3A> = <bevy::math::prelude::Dir3A as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::prelude::Dir3A>,
-                    other: Ref<bevy::math::prelude::Dir3A>|
-                {
-                    let output: bool = <bevy::math::prelude::Dir3A as std::cmp::PartialEq<
-                        bevy::math::prelude::Dir3A,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fast_renormalize",
-                |_self: Val<bevy::math::prelude::Dir3A>| {
-                    let output: Val<bevy::math::prelude::Dir3A> = bevy::math::prelude::Dir3A::fast_renormalize(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_xyz_unchecked",
-                |x: f32, y: f32, z: f32| {
-                    let output: Val<bevy::math::prelude::Dir3A> = bevy::math::prelude::Dir3A::from_xyz_unchecked(
-                            x,
-                            y,
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::prelude::Dir3A>, rhs: f32| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::prelude::Dir3A as std::ops::Mul<
-                        f32,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::prelude::Dir3A>| {
-                    let output: Val<bevy::math::prelude::Dir3A> = <bevy::math::prelude::Dir3A as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new_unchecked",
-                |value: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::prelude::Dir3A> = bevy::math::prelude::Dir3A::new_unchecked(
-                            value.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "slerp",
-                |
-                    _self: Val<bevy::math::prelude::Dir3A>,
-                    rhs: Val<bevy::math::prelude::Dir3A>,
-                    s: f32|
-                {
-                    let output: Val<bevy::math::prelude::Dir3A> = bevy::math::prelude::Dir3A::slerp(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                            s,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::prelude::IRect>::new(world)
-            .register(
-                "as_rect",
-                |_self: Ref<bevy::math::prelude::IRect>| {
-                    let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::IRect::as_rect(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_urect",
-                |_self: Ref<bevy::math::prelude::IRect>| {
-                    let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::IRect::as_urect(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::prelude::IRect>| {
-                    let output: () = <bevy::math::prelude::IRect as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "center",
-                |_self: Ref<bevy::math::prelude::IRect>| {
-                    let output: Val<bevy::math::prelude::IVec2> = bevy::math::prelude::IRect::center(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::prelude::IRect>| {
-                    let output: Val<bevy::math::prelude::IRect> = <bevy::math::prelude::IRect as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "contains",
-                |
-                    _self: Ref<bevy::math::prelude::IRect>,
-                    point: Val<bevy::math::prelude::IVec2>|
-                {
-                    let output: bool = bevy::math::prelude::IRect::contains(
-                            &_self,
-                            point.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::prelude::IRect>,
-                    other: Ref<bevy::math::prelude::IRect>|
-                {
-                    let output: bool = <bevy::math::prelude::IRect as std::cmp::PartialEq<
-                        bevy::math::prelude::IRect,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_center_half_size",
-                |
-                    origin: Val<bevy::math::prelude::IVec2>,
-                    half_size: Val<bevy::math::prelude::IVec2>|
-                {
-                    let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::IRect::from_center_half_size(
-                            origin.into_inner(),
-                            half_size.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_center_size",
-                |
-                    origin: Val<bevy::math::prelude::IVec2>,
-                    size: Val<bevy::math::prelude::IVec2>|
-                {
-                    let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::IRect::from_center_size(
-                            origin.into_inner(),
-                            size.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_corners",
-                |
-                    p0: Val<bevy::math::prelude::IVec2>,
-                    p1: Val<bevy::math::prelude::IVec2>|
-                {
-                    let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::IRect::from_corners(
-                            p0.into_inner(),
-                            p1.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "half_size",
-                |_self: Ref<bevy::math::prelude::IRect>| {
-                    let output: Val<bevy::math::prelude::IVec2> = bevy::math::prelude::IRect::half_size(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "height",
-                |_self: Ref<bevy::math::prelude::IRect>| {
-                    let output: i32 = bevy::math::prelude::IRect::height(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "inflate",
-                |_self: Ref<bevy::math::prelude::IRect>, expansion: i32| {
-                    let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::IRect::inflate(
-                            &_self,
-                            expansion,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "intersect",
-                |
-                    _self: Ref<bevy::math::prelude::IRect>,
-                    other: Val<bevy::math::prelude::IRect>|
-                {
-                    let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::IRect::intersect(
-                            &_self,
-                            other.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_empty",
-                |_self: Ref<bevy::math::prelude::IRect>| {
-                    let output: bool = bevy::math::prelude::IRect::is_empty(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x0: i32, y0: i32, x1: i32, y1: i32| {
-                    let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::IRect::new(
-                            x0,
-                            y0,
-                            x1,
-                            y1,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "size",
-                |_self: Ref<bevy::math::prelude::IRect>| {
-                    let output: Val<bevy::math::prelude::IVec2> = bevy::math::prelude::IRect::size(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "union",
-                |
-                    _self: Ref<bevy::math::prelude::IRect>,
-                    other: Val<bevy::math::prelude::IRect>|
-                {
-                    let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::IRect::union(
-                            &_self,
-                            other.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "union_point",
-                |
-                    _self: Ref<bevy::math::prelude::IRect>,
-                    other: Val<bevy::math::prelude::IVec2>|
-                {
-                    let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::IRect::union_point(
-                            &_self,
-                            other.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "width",
-                |_self: Ref<bevy::math::prelude::IRect>| {
-                    let output: i32 = bevy::math::prelude::IRect::width(&_self).into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::prelude::Rect>::new(world)
-            .register(
-                "as_irect",
-                |_self: Ref<bevy::math::prelude::Rect>| {
-                    let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::Rect::as_irect(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_urect",
-                |_self: Ref<bevy::math::prelude::Rect>| {
-                    let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::Rect::as_urect(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "center",
-                |_self: Ref<bevy::math::prelude::Rect>| {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::prelude::Rect::center(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::prelude::Rect>| {
-                    let output: Val<bevy::math::prelude::Rect> = <bevy::math::prelude::Rect as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "contains",
-                |
-                    _self: Ref<bevy::math::prelude::Rect>,
-                    point: Val<bevy::math::prelude::Vec2>|
-                {
-                    let output: bool = bevy::math::prelude::Rect::contains(
-                            &_self,
-                            point.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::prelude::Rect>,
-                    other: Ref<bevy::math::prelude::Rect>|
-                {
-                    let output: bool = <bevy::math::prelude::Rect as std::cmp::PartialEq<
-                        bevy::math::prelude::Rect,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_center_half_size",
-                |
-                    origin: Val<bevy::math::prelude::Vec2>,
-                    half_size: Val<bevy::math::prelude::Vec2>|
-                {
-                    let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::Rect::from_center_half_size(
-                            origin.into_inner(),
-                            half_size.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_center_size",
-                |
-                    origin: Val<bevy::math::prelude::Vec2>,
-                    size: Val<bevy::math::prelude::Vec2>|
-                {
-                    let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::Rect::from_center_size(
-                            origin.into_inner(),
-                            size.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_corners",
-                |p0: Val<bevy::math::prelude::Vec2>, p1: Val<bevy::math::prelude::Vec2>| {
-                    let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::Rect::from_corners(
-                            p0.into_inner(),
-                            p1.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "half_size",
-                |_self: Ref<bevy::math::prelude::Rect>| {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::prelude::Rect::half_size(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "height",
-                |_self: Ref<bevy::math::prelude::Rect>| {
-                    let output: f32 = bevy::math::prelude::Rect::height(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "inflate",
-                |_self: Ref<bevy::math::prelude::Rect>, expansion: f32| {
-                    let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::Rect::inflate(
-                            &_self,
-                            expansion,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "intersect",
-                |
-                    _self: Ref<bevy::math::prelude::Rect>,
-                    other: Val<bevy::math::prelude::Rect>|
-                {
-                    let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::Rect::intersect(
-                            &_self,
-                            other.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_empty",
-                |_self: Ref<bevy::math::prelude::Rect>| {
-                    let output: bool = bevy::math::prelude::Rect::is_empty(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x0: f32, y0: f32, x1: f32, y1: f32| {
-                    let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::Rect::new(
-                            x0,
-                            y0,
-                            x1,
-                            y1,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize",
-                |
-                    _self: Ref<bevy::math::prelude::Rect>,
-                    other: Val<bevy::math::prelude::Rect>|
-                {
-                    let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::Rect::normalize(
-                            &_self,
-                            other.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "size",
-                |_self: Ref<bevy::math::prelude::Rect>| {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::prelude::Rect::size(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "union",
-                |
-                    _self: Ref<bevy::math::prelude::Rect>,
-                    other: Val<bevy::math::prelude::Rect>|
-                {
-                    let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::Rect::union(
-                            &_self,
-                            other.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "union_point",
-                |
-                    _self: Ref<bevy::math::prelude::Rect>,
-                    other: Val<bevy::math::prelude::Vec2>|
-                {
-                    let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::Rect::union_point(
-                            &_self,
-                            other.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "width",
-                |_self: Ref<bevy::math::prelude::Rect>| {
-                    let output: f32 = bevy::math::prelude::Rect::width(&_self).into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::prelude::URect>::new(world)
-            .register(
-                "as_irect",
-                |_self: Ref<bevy::math::prelude::URect>| {
-                    let output: Val<bevy::math::prelude::IRect> = bevy::math::prelude::URect::as_irect(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_rect",
-                |_self: Ref<bevy::math::prelude::URect>| {
-                    let output: Val<bevy::math::prelude::Rect> = bevy::math::prelude::URect::as_rect(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::prelude::URect>| {
-                    let output: () = <bevy::math::prelude::URect as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "center",
-                |_self: Ref<bevy::math::prelude::URect>| {
-                    let output: Val<bevy::math::prelude::UVec2> = bevy::math::prelude::URect::center(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::prelude::URect>| {
-                    let output: Val<bevy::math::prelude::URect> = <bevy::math::prelude::URect as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "contains",
-                |
-                    _self: Ref<bevy::math::prelude::URect>,
-                    point: Val<bevy::math::prelude::UVec2>|
-                {
-                    let output: bool = bevy::math::prelude::URect::contains(
-                            &_self,
-                            point.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::prelude::URect>,
-                    other: Ref<bevy::math::prelude::URect>|
-                {
-                    let output: bool = <bevy::math::prelude::URect as std::cmp::PartialEq<
-                        bevy::math::prelude::URect,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_center_half_size",
-                |
-                    origin: Val<bevy::math::prelude::UVec2>,
-                    half_size: Val<bevy::math::prelude::UVec2>|
-                {
-                    let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::URect::from_center_half_size(
-                            origin.into_inner(),
-                            half_size.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_center_size",
-                |
-                    origin: Val<bevy::math::prelude::UVec2>,
-                    size: Val<bevy::math::prelude::UVec2>|
-                {
-                    let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::URect::from_center_size(
-                            origin.into_inner(),
-                            size.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_corners",
-                |
-                    p0: Val<bevy::math::prelude::UVec2>,
-                    p1: Val<bevy::math::prelude::UVec2>|
-                {
-                    let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::URect::from_corners(
-                            p0.into_inner(),
-                            p1.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "half_size",
-                |_self: Ref<bevy::math::prelude::URect>| {
-                    let output: Val<bevy::math::prelude::UVec2> = bevy::math::prelude::URect::half_size(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "height",
-                |_self: Ref<bevy::math::prelude::URect>| {
-                    let output: u32 = bevy::math::prelude::URect::height(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "inflate",
-                |_self: Ref<bevy::math::prelude::URect>, expansion: i32| {
-                    let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::URect::inflate(
-                            &_self,
-                            expansion,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "intersect",
-                |
-                    _self: Ref<bevy::math::prelude::URect>,
-                    other: Val<bevy::math::prelude::URect>|
-                {
-                    let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::URect::intersect(
-                            &_self,
-                            other.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_empty",
-                |_self: Ref<bevy::math::prelude::URect>| {
-                    let output: bool = bevy::math::prelude::URect::is_empty(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x0: u32, y0: u32, x1: u32, y1: u32| {
-                    let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::URect::new(
-                            x0,
-                            y0,
-                            x1,
-                            y1,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "size",
-                |_self: Ref<bevy::math::prelude::URect>| {
-                    let output: Val<bevy::math::prelude::UVec2> = bevy::math::prelude::URect::size(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "union",
-                |
-                    _self: Ref<bevy::math::prelude::URect>,
-                    other: Val<bevy::math::prelude::URect>|
-                {
-                    let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::URect::union(
-                            &_self,
-                            other.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "union_point",
-                |
-                    _self: Ref<bevy::math::prelude::URect>,
-                    other: Val<bevy::math::prelude::UVec2>|
-                {
-                    let output: Val<bevy::math::prelude::URect> = bevy::math::prelude::URect::union_point(
-                            &_self,
-                            other.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "width",
-                |_self: Ref<bevy::math::prelude::URect>| {
-                    let output: u32 = bevy::math::prelude::URect::width(&_self).into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::Affine3>::new(world);
-        NamespaceBuilder::<::bevy::math::bounding::Aabb2d>::new(world)
-            .register(
-                "bounding_circle",
-                |_self: Ref<bevy::math::bounding::Aabb2d>| {
-                    let output: Val<bevy::math::bounding::BoundingCircle> = bevy::math::bounding::Aabb2d::bounding_circle(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::bounding::Aabb2d>| {
-                    let output: Val<bevy::math::bounding::Aabb2d> = <bevy::math::bounding::Aabb2d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "closest_point",
-                |
-                    _self: Ref<bevy::math::bounding::Aabb2d>,
-                    point: Val<bevy::math::prelude::Vec2>|
-                {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::bounding::Aabb2d::closest_point(
-                            &_self,
-                            point.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |
-                    center: Val<bevy::math::prelude::Vec2>,
-                    half_size: Val<bevy::math::prelude::Vec2>|
-                {
-                    let output: Val<bevy::math::bounding::Aabb2d> = bevy::math::bounding::Aabb2d::new(
-                            center.into_inner(),
-                            half_size.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::bounding::BoundingCircle>::new(world)
-            .register(
-                "aabb_2d",
-                |_self: Ref<bevy::math::bounding::BoundingCircle>| {
-                    let output: Val<bevy::math::bounding::Aabb2d> = bevy::math::bounding::BoundingCircle::aabb_2d(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::bounding::BoundingCircle>| {
-                    let output: Val<bevy::math::bounding::BoundingCircle> = <bevy::math::bounding::BoundingCircle as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "closest_point",
-                |
-                    _self: Ref<bevy::math::bounding::BoundingCircle>,
-                    point: Val<bevy::math::prelude::Vec2>|
-                {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::bounding::BoundingCircle::closest_point(
-                            &_self,
-                            point.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |center: Val<bevy::math::prelude::Vec2>, radius: f32| {
-                    let output: Val<bevy::math::bounding::BoundingCircle> = bevy::math::bounding::BoundingCircle::new(
-                            center.into_inner(),
-                            radius,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "radius",
-                |_self: Ref<bevy::math::bounding::BoundingCircle>| {
-                    let output: f32 = bevy::math::bounding::BoundingCircle::radius(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Circle>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Circle>| {
-                    let output: Val<bevy::math::primitives::Circle> = <bevy::math::primitives::Circle as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "closest_point",
-                |
-                    _self: Ref<bevy::math::primitives::Circle>,
-                    point: Val<bevy::math::prelude::Vec2>|
-                {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Circle::closest_point(
-                            &_self,
-                            point.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "diameter",
-                |_self: Ref<bevy::math::primitives::Circle>| {
-                    let output: f32 = bevy::math::primitives::Circle::diameter(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Circle>,
-                    other: Ref<bevy::math::primitives::Circle>|
-                {
-                    let output: bool = <bevy::math::primitives::Circle as std::cmp::PartialEq<
-                        bevy::math::primitives::Circle,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |radius: f32| {
-                    let output: Val<bevy::math::primitives::Circle> = bevy::math::primitives::Circle::new(
-                            radius,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Annulus>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Annulus>| {
-                    let output: Val<bevy::math::primitives::Annulus> = <bevy::math::primitives::Annulus as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "closest_point",
-                |
-                    _self: Ref<bevy::math::primitives::Annulus>,
-                    point: Val<bevy::math::prelude::Vec2>|
-                {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Annulus::closest_point(
-                            &_self,
-                            point.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "diameter",
-                |_self: Ref<bevy::math::primitives::Annulus>| {
-                    let output: f32 = bevy::math::primitives::Annulus::diameter(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Annulus>,
-                    other: Ref<bevy::math::primitives::Annulus>|
-                {
-                    let output: bool = <bevy::math::primitives::Annulus as std::cmp::PartialEq<
-                        bevy::math::primitives::Annulus,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |inner_radius: f32, outer_radius: f32| {
-                    let output: Val<bevy::math::primitives::Annulus> = bevy::math::primitives::Annulus::new(
-                            inner_radius,
-                            outer_radius,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "thickness",
-                |_self: Ref<bevy::math::primitives::Annulus>| {
-                    let output: f32 = bevy::math::primitives::Annulus::thickness(&_self)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Arc2d>::new(world)
-            .register(
-                "angle",
-                |_self: Ref<bevy::math::primitives::Arc2d>| {
-                    let output: f32 = bevy::math::primitives::Arc2d::angle(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "apothem",
-                |_self: Ref<bevy::math::primitives::Arc2d>| {
-                    let output: f32 = bevy::math::primitives::Arc2d::apothem(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "chord_length",
-                |_self: Ref<bevy::math::primitives::Arc2d>| {
-                    let output: f32 = bevy::math::primitives::Arc2d::chord_length(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "chord_midpoint",
-                |_self: Ref<bevy::math::primitives::Arc2d>| {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Arc2d::chord_midpoint(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Arc2d>| {
-                    let output: Val<bevy::math::primitives::Arc2d> = <bevy::math::primitives::Arc2d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Arc2d>,
-                    other: Ref<bevy::math::primitives::Arc2d>|
-                {
-                    let output: bool = <bevy::math::primitives::Arc2d as std::cmp::PartialEq<
-                        bevy::math::primitives::Arc2d,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_degrees",
-                |radius: f32, angle: f32| {
-                    let output: Val<bevy::math::primitives::Arc2d> = bevy::math::primitives::Arc2d::from_degrees(
-                            radius,
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_radians",
-                |radius: f32, angle: f32| {
-                    let output: Val<bevy::math::primitives::Arc2d> = bevy::math::primitives::Arc2d::from_radians(
-                            radius,
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_turns",
-                |radius: f32, fraction: f32| {
-                    let output: Val<bevy::math::primitives::Arc2d> = bevy::math::primitives::Arc2d::from_turns(
-                            radius,
-                            fraction,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "half_chord_length",
-                |_self: Ref<bevy::math::primitives::Arc2d>| {
-                    let output: f32 = bevy::math::primitives::Arc2d::half_chord_length(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_major",
-                |_self: Ref<bevy::math::primitives::Arc2d>| {
-                    let output: bool = bevy::math::primitives::Arc2d::is_major(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_minor",
-                |_self: Ref<bevy::math::primitives::Arc2d>| {
-                    let output: bool = bevy::math::primitives::Arc2d::is_minor(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "left_endpoint",
-                |_self: Ref<bevy::math::primitives::Arc2d>| {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Arc2d::left_endpoint(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length",
-                |_self: Ref<bevy::math::primitives::Arc2d>| {
-                    let output: f32 = bevy::math::primitives::Arc2d::length(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "midpoint",
-                |_self: Ref<bevy::math::primitives::Arc2d>| {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Arc2d::midpoint(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |radius: f32, half_angle: f32| {
-                    let output: Val<bevy::math::primitives::Arc2d> = bevy::math::primitives::Arc2d::new(
-                            radius,
-                            half_angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "right_endpoint",
-                |_self: Ref<bevy::math::primitives::Arc2d>| {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Arc2d::right_endpoint(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sagitta",
-                |_self: Ref<bevy::math::primitives::Arc2d>| {
-                    let output: f32 = bevy::math::primitives::Arc2d::sagitta(&_self)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Capsule2d>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Capsule2d>| {
-                    let output: Val<bevy::math::primitives::Capsule2d> = <bevy::math::primitives::Capsule2d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Capsule2d>,
-                    other: Ref<bevy::math::primitives::Capsule2d>|
-                {
-                    let output: bool = <bevy::math::primitives::Capsule2d as std::cmp::PartialEq<
-                        bevy::math::primitives::Capsule2d,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |radius: f32, length: f32| {
-                    let output: Val<bevy::math::primitives::Capsule2d> = bevy::math::primitives::Capsule2d::new(
-                            radius,
-                            length,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_inner_rectangle",
-                |_self: Ref<bevy::math::primitives::Capsule2d>| {
-                    let output: Val<bevy::math::primitives::Rectangle> = bevy::math::primitives::Capsule2d::to_inner_rectangle(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::CircularSector>::new(world)
-            .register(
-                "angle",
-                |_self: Ref<bevy::math::primitives::CircularSector>| {
-                    let output: f32 = bevy::math::primitives::CircularSector::angle(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "apothem",
-                |_self: Ref<bevy::math::primitives::CircularSector>| {
-                    let output: f32 = bevy::math::primitives::CircularSector::apothem(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "arc_length",
-                |_self: Ref<bevy::math::primitives::CircularSector>| {
-                    let output: f32 = bevy::math::primitives::CircularSector::arc_length(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "chord_length",
-                |_self: Ref<bevy::math::primitives::CircularSector>| {
-                    let output: f32 = bevy::math::primitives::CircularSector::chord_length(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "chord_midpoint",
-                |_self: Ref<bevy::math::primitives::CircularSector>| {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::CircularSector::chord_midpoint(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::CircularSector>| {
-                    let output: Val<bevy::math::primitives::CircularSector> = <bevy::math::primitives::CircularSector as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::CircularSector>,
-                    other: Ref<bevy::math::primitives::CircularSector>|
-                {
-                    let output: bool = <bevy::math::primitives::CircularSector as std::cmp::PartialEq<
-                        bevy::math::primitives::CircularSector,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_degrees",
-                |radius: f32, angle: f32| {
-                    let output: Val<bevy::math::primitives::CircularSector> = bevy::math::primitives::CircularSector::from_degrees(
-                            radius,
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_radians",
-                |radius: f32, angle: f32| {
-                    let output: Val<bevy::math::primitives::CircularSector> = bevy::math::primitives::CircularSector::from_radians(
-                            radius,
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_turns",
-                |radius: f32, fraction: f32| {
-                    let output: Val<bevy::math::primitives::CircularSector> = bevy::math::primitives::CircularSector::from_turns(
-                            radius,
-                            fraction,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "half_angle",
-                |_self: Ref<bevy::math::primitives::CircularSector>| {
-                    let output: f32 = bevy::math::primitives::CircularSector::half_angle(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "half_chord_length",
-                |_self: Ref<bevy::math::primitives::CircularSector>| {
-                    let output: f32 = bevy::math::primitives::CircularSector::half_chord_length(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |radius: f32, angle: f32| {
-                    let output: Val<bevy::math::primitives::CircularSector> = bevy::math::primitives::CircularSector::new(
-                            radius,
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "radius",
-                |_self: Ref<bevy::math::primitives::CircularSector>| {
-                    let output: f32 = bevy::math::primitives::CircularSector::radius(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sagitta",
-                |_self: Ref<bevy::math::primitives::CircularSector>| {
-                    let output: f32 = bevy::math::primitives::CircularSector::sagitta(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::CircularSegment>::new(world)
-            .register(
-                "angle",
-                |_self: Ref<bevy::math::primitives::CircularSegment>| {
-                    let output: f32 = bevy::math::primitives::CircularSegment::angle(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "apothem",
-                |_self: Ref<bevy::math::primitives::CircularSegment>| {
-                    let output: f32 = bevy::math::primitives::CircularSegment::apothem(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "arc_length",
-                |_self: Ref<bevy::math::primitives::CircularSegment>| {
-                    let output: f32 = bevy::math::primitives::CircularSegment::arc_length(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "chord_length",
-                |_self: Ref<bevy::math::primitives::CircularSegment>| {
-                    let output: f32 = bevy::math::primitives::CircularSegment::chord_length(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "chord_midpoint",
-                |_self: Ref<bevy::math::primitives::CircularSegment>| {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::CircularSegment::chord_midpoint(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::CircularSegment>| {
-                    let output: Val<bevy::math::primitives::CircularSegment> = <bevy::math::primitives::CircularSegment as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::CircularSegment>,
-                    other: Ref<bevy::math::primitives::CircularSegment>|
-                {
-                    let output: bool = <bevy::math::primitives::CircularSegment as std::cmp::PartialEq<
-                        bevy::math::primitives::CircularSegment,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_degrees",
-                |radius: f32, angle: f32| {
-                    let output: Val<bevy::math::primitives::CircularSegment> = bevy::math::primitives::CircularSegment::from_degrees(
-                            radius,
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_radians",
-                |radius: f32, angle: f32| {
-                    let output: Val<bevy::math::primitives::CircularSegment> = bevy::math::primitives::CircularSegment::from_radians(
-                            radius,
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_turns",
-                |radius: f32, fraction: f32| {
-                    let output: Val<bevy::math::primitives::CircularSegment> = bevy::math::primitives::CircularSegment::from_turns(
-                            radius,
-                            fraction,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "half_angle",
-                |_self: Ref<bevy::math::primitives::CircularSegment>| {
-                    let output: f32 = bevy::math::primitives::CircularSegment::half_angle(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "half_chord_length",
-                |_self: Ref<bevy::math::primitives::CircularSegment>| {
-                    let output: f32 = bevy::math::primitives::CircularSegment::half_chord_length(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |radius: f32, angle: f32| {
-                    let output: Val<bevy::math::primitives::CircularSegment> = bevy::math::primitives::CircularSegment::new(
-                            radius,
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "radius",
-                |_self: Ref<bevy::math::primitives::CircularSegment>| {
-                    let output: f32 = bevy::math::primitives::CircularSegment::radius(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sagitta",
-                |_self: Ref<bevy::math::primitives::CircularSegment>| {
-                    let output: f32 = bevy::math::primitives::CircularSegment::sagitta(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Ellipse>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Ellipse>| {
-                    let output: Val<bevy::math::primitives::Ellipse> = <bevy::math::primitives::Ellipse as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eccentricity",
-                |_self: Ref<bevy::math::primitives::Ellipse>| {
-                    let output: f32 = bevy::math::primitives::Ellipse::eccentricity(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Ellipse>,
-                    other: Ref<bevy::math::primitives::Ellipse>|
-                {
-                    let output: bool = <bevy::math::primitives::Ellipse as std::cmp::PartialEq<
-                        bevy::math::primitives::Ellipse,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "focal_length",
-                |_self: Ref<bevy::math::primitives::Ellipse>| {
-                    let output: f32 = bevy::math::primitives::Ellipse::focal_length(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_size",
-                |size: Val<bevy::math::prelude::Vec2>| {
-                    let output: Val<bevy::math::primitives::Ellipse> = bevy::math::primitives::Ellipse::from_size(
-                            size.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |half_width: f32, half_height: f32| {
-                    let output: Val<bevy::math::primitives::Ellipse> = bevy::math::primitives::Ellipse::new(
-                            half_width,
-                            half_height,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "semi_major",
-                |_self: Ref<bevy::math::primitives::Ellipse>| {
-                    let output: f32 = bevy::math::primitives::Ellipse::semi_major(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "semi_minor",
-                |_self: Ref<bevy::math::primitives::Ellipse>| {
-                    let output: f32 = bevy::math::primitives::Ellipse::semi_minor(&_self)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Line2d>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Line2d>| {
-                    let output: Val<bevy::math::primitives::Line2d> = <bevy::math::primitives::Line2d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Line2d>,
-                    other: Ref<bevy::math::primitives::Line2d>|
-                {
-                    let output: bool = <bevy::math::primitives::Line2d as std::cmp::PartialEq<
-                        bevy::math::primitives::Line2d,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Plane2d>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Plane2d>| {
-                    let output: Val<bevy::math::primitives::Plane2d> = <bevy::math::primitives::Plane2d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Plane2d>,
-                    other: Ref<bevy::math::primitives::Plane2d>|
-                {
-                    let output: bool = <bevy::math::primitives::Plane2d as std::cmp::PartialEq<
-                        bevy::math::primitives::Plane2d,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |normal: Val<bevy::math::prelude::Vec2>| {
-                    let output: Val<bevy::math::primitives::Plane2d> = bevy::math::primitives::Plane2d::new(
-                            normal.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Rectangle>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Rectangle>| {
-                    let output: Val<bevy::math::primitives::Rectangle> = <bevy::math::primitives::Rectangle as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "closest_point",
-                |
-                    _self: Ref<bevy::math::primitives::Rectangle>,
-                    point: Val<bevy::math::prelude::Vec2>|
-                {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Rectangle::closest_point(
-                            &_self,
-                            point.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Rectangle>,
-                    other: Ref<bevy::math::primitives::Rectangle>|
-                {
-                    let output: bool = <bevy::math::primitives::Rectangle as std::cmp::PartialEq<
-                        bevy::math::primitives::Rectangle,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_corners",
-                |
-                    point1: Val<bevy::math::prelude::Vec2>,
-                    point2: Val<bevy::math::prelude::Vec2>|
-                {
-                    let output: Val<bevy::math::primitives::Rectangle> = bevy::math::primitives::Rectangle::from_corners(
-                            point1.into_inner(),
-                            point2.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_length",
-                |length: f32| {
-                    let output: Val<bevy::math::primitives::Rectangle> = bevy::math::primitives::Rectangle::from_length(
-                            length,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_size",
-                |size: Val<bevy::math::prelude::Vec2>| {
-                    let output: Val<bevy::math::primitives::Rectangle> = bevy::math::primitives::Rectangle::from_size(
-                            size.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |width: f32, height: f32| {
-                    let output: Val<bevy::math::primitives::Rectangle> = bevy::math::primitives::Rectangle::new(
-                            width,
-                            height,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "size",
-                |_self: Ref<bevy::math::primitives::Rectangle>| {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Rectangle::size(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::RegularPolygon>::new(world)
-            .register(
-                "circumradius",
-                |_self: Ref<bevy::math::primitives::RegularPolygon>| {
-                    let output: f32 = bevy::math::primitives::RegularPolygon::circumradius(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::RegularPolygon>| {
-                    let output: Val<bevy::math::primitives::RegularPolygon> = <bevy::math::primitives::RegularPolygon as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::RegularPolygon>,
-                    other: Ref<bevy::math::primitives::RegularPolygon>|
-                {
-                    let output: bool = <bevy::math::primitives::RegularPolygon as std::cmp::PartialEq<
-                        bevy::math::primitives::RegularPolygon,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "external_angle_degrees",
-                |_self: Ref<bevy::math::primitives::RegularPolygon>| {
-                    let output: f32 = bevy::math::primitives::RegularPolygon::external_angle_degrees(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "external_angle_radians",
-                |_self: Ref<bevy::math::primitives::RegularPolygon>| {
-                    let output: f32 = bevy::math::primitives::RegularPolygon::external_angle_radians(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inradius",
-                |_self: Ref<bevy::math::primitives::RegularPolygon>| {
-                    let output: f32 = bevy::math::primitives::RegularPolygon::inradius(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "internal_angle_degrees",
-                |_self: Ref<bevy::math::primitives::RegularPolygon>| {
-                    let output: f32 = bevy::math::primitives::RegularPolygon::internal_angle_degrees(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "internal_angle_radians",
-                |_self: Ref<bevy::math::primitives::RegularPolygon>| {
-                    let output: f32 = bevy::math::primitives::RegularPolygon::internal_angle_radians(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |circumradius: f32, sides: u32| {
-                    let output: Val<bevy::math::primitives::RegularPolygon> = bevy::math::primitives::RegularPolygon::new(
-                            circumradius,
-                            sides,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "side_length",
-                |_self: Ref<bevy::math::primitives::RegularPolygon>| {
-                    let output: f32 = bevy::math::primitives::RegularPolygon::side_length(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Rhombus>::new(world)
-            .register(
-                "circumradius",
-                |_self: Ref<bevy::math::primitives::Rhombus>| {
-                    let output: f32 = bevy::math::primitives::Rhombus::circumradius(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Rhombus>| {
-                    let output: Val<bevy::math::primitives::Rhombus> = <bevy::math::primitives::Rhombus as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "closest_point",
-                |
-                    _self: Ref<bevy::math::primitives::Rhombus>,
-                    point: Val<bevy::math::prelude::Vec2>|
-                {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Rhombus::closest_point(
-                            &_self,
-                            point.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Rhombus>,
-                    other: Ref<bevy::math::primitives::Rhombus>|
-                {
-                    let output: bool = <bevy::math::primitives::Rhombus as std::cmp::PartialEq<
-                        bevy::math::primitives::Rhombus,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_inradius",
-                |inradius: f32| {
-                    let output: Val<bevy::math::primitives::Rhombus> = bevy::math::primitives::Rhombus::from_inradius(
-                            inradius,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_side",
-                |side: f32| {
-                    let output: Val<bevy::math::primitives::Rhombus> = bevy::math::primitives::Rhombus::from_side(
-                            side,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inradius",
-                |_self: Ref<bevy::math::primitives::Rhombus>| {
-                    let output: f32 = bevy::math::primitives::Rhombus::inradius(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |horizontal_diagonal: f32, vertical_diagonal: f32| {
-                    let output: Val<bevy::math::primitives::Rhombus> = bevy::math::primitives::Rhombus::new(
-                            horizontal_diagonal,
-                            vertical_diagonal,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "side",
-                |_self: Ref<bevy::math::primitives::Rhombus>| {
-                    let output: f32 = bevy::math::primitives::Rhombus::side(&_self)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Segment2d>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Segment2d>| {
-                    let output: Val<bevy::math::primitives::Segment2d> = <bevy::math::primitives::Segment2d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Segment2d>,
-                    other: Ref<bevy::math::primitives::Segment2d>|
-                {
-                    let output: bool = <bevy::math::primitives::Segment2d as std::cmp::PartialEq<
-                        bevy::math::primitives::Segment2d,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |direction: Val<bevy::math::prelude::Dir2>, length: f32| {
-                    let output: Val<bevy::math::primitives::Segment2d> = bevy::math::primitives::Segment2d::new(
-                            direction.into_inner(),
-                            length,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "point1",
-                |_self: Ref<bevy::math::primitives::Segment2d>| {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Segment2d::point1(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "point2",
-                |_self: Ref<bevy::math::primitives::Segment2d>| {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::primitives::Segment2d::point2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Triangle2d>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Triangle2d>| {
-                    let output: Val<bevy::math::primitives::Triangle2d> = <bevy::math::primitives::Triangle2d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Triangle2d>,
-                    other: Ref<bevy::math::primitives::Triangle2d>|
-                {
-                    let output: bool = <bevy::math::primitives::Triangle2d as std::cmp::PartialEq<
-                        bevy::math::primitives::Triangle2d,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_acute",
-                |_self: Ref<bevy::math::primitives::Triangle2d>| {
-                    let output: bool = bevy::math::primitives::Triangle2d::is_acute(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_degenerate",
-                |_self: Ref<bevy::math::primitives::Triangle2d>| {
-                    let output: bool = bevy::math::primitives::Triangle2d::is_degenerate(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_obtuse",
-                |_self: Ref<bevy::math::primitives::Triangle2d>| {
-                    let output: bool = bevy::math::primitives::Triangle2d::is_obtuse(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |
-                    a: Val<bevy::math::prelude::Vec2>,
-                    b: Val<bevy::math::prelude::Vec2>,
-                    c: Val<bevy::math::prelude::Vec2>|
-                {
-                    let output: Val<bevy::math::primitives::Triangle2d> = bevy::math::primitives::Triangle2d::new(
-                            a.into_inner(),
-                            b.into_inner(),
-                            c.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reverse",
-                |mut _self: Mut<bevy::math::primitives::Triangle2d>| {
-                    let output: () = bevy::math::primitives::Triangle2d::reverse(
-                            &mut _self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reversed",
-                |_self: Val<bevy::math::primitives::Triangle2d>| {
-                    let output: Val<bevy::math::primitives::Triangle2d> = bevy::math::primitives::Triangle2d::reversed(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::bounding::Aabb3d>::new(world)
-            .register(
-                "bounding_sphere",
-                |_self: Ref<bevy::math::bounding::Aabb3d>| {
-                    let output: Val<bevy::math::bounding::BoundingSphere> = bevy::math::bounding::Aabb3d::bounding_sphere(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::bounding::Aabb3d>| {
-                    let output: Val<bevy::math::bounding::Aabb3d> = <bevy::math::bounding::Aabb3d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::bounding::BoundingSphere>::new(world)
-            .register(
-                "aabb_3d",
-                |_self: Ref<bevy::math::bounding::BoundingSphere>| {
-                    let output: Val<bevy::math::bounding::Aabb3d> = bevy::math::bounding::BoundingSphere::aabb_3d(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::bounding::BoundingSphere>| {
-                    let output: Val<bevy::math::bounding::BoundingSphere> = <bevy::math::bounding::BoundingSphere as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "radius",
-                |_self: Ref<bevy::math::bounding::BoundingSphere>| {
-                    let output: f32 = bevy::math::bounding::BoundingSphere::radius(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Sphere>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Sphere>| {
-                    let output: Val<bevy::math::primitives::Sphere> = <bevy::math::primitives::Sphere as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "closest_point",
-                |
-                    _self: Ref<bevy::math::primitives::Sphere>,
-                    point: Val<bevy::math::prelude::Vec3>|
-                {
-                    let output: Val<bevy::math::prelude::Vec3> = bevy::math::primitives::Sphere::closest_point(
-                            &_self,
-                            point.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "diameter",
-                |_self: Ref<bevy::math::primitives::Sphere>| {
-                    let output: f32 = bevy::math::primitives::Sphere::diameter(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Sphere>,
-                    other: Ref<bevy::math::primitives::Sphere>|
-                {
-                    let output: bool = <bevy::math::primitives::Sphere as std::cmp::PartialEq<
-                        bevy::math::primitives::Sphere,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |radius: f32| {
-                    let output: Val<bevy::math::primitives::Sphere> = bevy::math::primitives::Sphere::new(
-                            radius,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Cuboid>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Cuboid>| {
-                    let output: Val<bevy::math::primitives::Cuboid> = <bevy::math::primitives::Cuboid as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "closest_point",
-                |
-                    _self: Ref<bevy::math::primitives::Cuboid>,
-                    point: Val<bevy::math::prelude::Vec3>|
-                {
-                    let output: Val<bevy::math::prelude::Vec3> = bevy::math::primitives::Cuboid::closest_point(
-                            &_self,
-                            point.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Cuboid>,
-                    other: Ref<bevy::math::primitives::Cuboid>|
-                {
-                    let output: bool = <bevy::math::primitives::Cuboid as std::cmp::PartialEq<
-                        bevy::math::primitives::Cuboid,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_corners",
-                |
-                    point1: Val<bevy::math::prelude::Vec3>,
-                    point2: Val<bevy::math::prelude::Vec3>|
-                {
-                    let output: Val<bevy::math::primitives::Cuboid> = bevy::math::primitives::Cuboid::from_corners(
-                            point1.into_inner(),
-                            point2.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_length",
-                |length: f32| {
-                    let output: Val<bevy::math::primitives::Cuboid> = bevy::math::primitives::Cuboid::from_length(
-                            length,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_size",
-                |size: Val<bevy::math::prelude::Vec3>| {
-                    let output: Val<bevy::math::primitives::Cuboid> = bevy::math::primitives::Cuboid::from_size(
-                            size.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x_length: f32, y_length: f32, z_length: f32| {
-                    let output: Val<bevy::math::primitives::Cuboid> = bevy::math::primitives::Cuboid::new(
-                            x_length,
-                            y_length,
-                            z_length,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "size",
-                |_self: Ref<bevy::math::primitives::Cuboid>| {
-                    let output: Val<bevy::math::prelude::Vec3> = bevy::math::primitives::Cuboid::size(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Cylinder>::new(world)
-            .register(
-                "base",
-                |_self: Ref<bevy::math::primitives::Cylinder>| {
-                    let output: Val<bevy::math::primitives::Circle> = bevy::math::primitives::Cylinder::base(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "base_area",
-                |_self: Ref<bevy::math::primitives::Cylinder>| {
-                    let output: f32 = bevy::math::primitives::Cylinder::base_area(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Cylinder>| {
-                    let output: Val<bevy::math::primitives::Cylinder> = <bevy::math::primitives::Cylinder as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Cylinder>,
-                    other: Ref<bevy::math::primitives::Cylinder>|
-                {
-                    let output: bool = <bevy::math::primitives::Cylinder as std::cmp::PartialEq<
-                        bevy::math::primitives::Cylinder,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "lateral_area",
-                |_self: Ref<bevy::math::primitives::Cylinder>| {
-                    let output: f32 = bevy::math::primitives::Cylinder::lateral_area(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |radius: f32, height: f32| {
-                    let output: Val<bevy::math::primitives::Cylinder> = bevy::math::primitives::Cylinder::new(
-                            radius,
-                            height,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Capsule3d>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Capsule3d>| {
-                    let output: Val<bevy::math::primitives::Capsule3d> = <bevy::math::primitives::Capsule3d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Capsule3d>,
-                    other: Ref<bevy::math::primitives::Capsule3d>|
-                {
-                    let output: bool = <bevy::math::primitives::Capsule3d as std::cmp::PartialEq<
-                        bevy::math::primitives::Capsule3d,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |radius: f32, length: f32| {
-                    let output: Val<bevy::math::primitives::Capsule3d> = bevy::math::primitives::Capsule3d::new(
-                            radius,
-                            length,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cylinder",
-                |_self: Ref<bevy::math::primitives::Capsule3d>| {
-                    let output: Val<bevy::math::primitives::Cylinder> = bevy::math::primitives::Capsule3d::to_cylinder(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Cone>::new(world)
-            .register(
-                "base",
-                |_self: Ref<bevy::math::primitives::Cone>| {
-                    let output: Val<bevy::math::primitives::Circle> = bevy::math::primitives::Cone::base(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "base_area",
-                |_self: Ref<bevy::math::primitives::Cone>| {
-                    let output: f32 = bevy::math::primitives::Cone::base_area(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Cone>| {
-                    let output: Val<bevy::math::primitives::Cone> = <bevy::math::primitives::Cone as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Cone>,
-                    other: Ref<bevy::math::primitives::Cone>|
-                {
-                    let output: bool = <bevy::math::primitives::Cone as std::cmp::PartialEq<
-                        bevy::math::primitives::Cone,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "lateral_area",
-                |_self: Ref<bevy::math::primitives::Cone>| {
-                    let output: f32 = bevy::math::primitives::Cone::lateral_area(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |radius: f32, height: f32| {
-                    let output: Val<bevy::math::primitives::Cone> = bevy::math::primitives::Cone::new(
-                            radius,
-                            height,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "slant_height",
-                |_self: Ref<bevy::math::primitives::Cone>| {
-                    let output: f32 = bevy::math::primitives::Cone::slant_height(&_self)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::ConicalFrustum>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::ConicalFrustum>| {
-                    let output: Val<bevy::math::primitives::ConicalFrustum> = <bevy::math::primitives::ConicalFrustum as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::ConicalFrustum>,
-                    other: Ref<bevy::math::primitives::ConicalFrustum>|
-                {
-                    let output: bool = <bevy::math::primitives::ConicalFrustum as std::cmp::PartialEq<
-                        bevy::math::primitives::ConicalFrustum,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::InfinitePlane3d>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::InfinitePlane3d>| {
-                    let output: Val<bevy::math::primitives::InfinitePlane3d> = <bevy::math::primitives::InfinitePlane3d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::InfinitePlane3d>,
-                    other: Ref<bevy::math::primitives::InfinitePlane3d>|
-                {
-                    let output: bool = <bevy::math::primitives::InfinitePlane3d as std::cmp::PartialEq<
-                        bevy::math::primitives::InfinitePlane3d,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "isometry_from_xy",
-                |
-                    _self: Ref<bevy::math::primitives::InfinitePlane3d>,
-                    origin: Val<bevy::math::prelude::Vec3>|
-                {
-                    let output: Val<bevy::math::Isometry3d> = bevy::math::primitives::InfinitePlane3d::isometry_from_xy(
-                            &_self,
-                            origin.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "isometry_into_xy",
-                |
-                    _self: Ref<bevy::math::primitives::InfinitePlane3d>,
-                    origin: Val<bevy::math::prelude::Vec3>|
-                {
-                    let output: Val<bevy::math::Isometry3d> = bevy::math::primitives::InfinitePlane3d::isometry_into_xy(
-                            &_self,
-                            origin.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Line3d>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Line3d>| {
-                    let output: Val<bevy::math::primitives::Line3d> = <bevy::math::primitives::Line3d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Line3d>,
-                    other: Ref<bevy::math::primitives::Line3d>|
-                {
-                    let output: bool = <bevy::math::primitives::Line3d as std::cmp::PartialEq<
-                        bevy::math::primitives::Line3d,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Segment3d>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Segment3d>| {
-                    let output: Val<bevy::math::primitives::Segment3d> = <bevy::math::primitives::Segment3d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Segment3d>,
-                    other: Ref<bevy::math::primitives::Segment3d>|
-                {
-                    let output: bool = <bevy::math::primitives::Segment3d as std::cmp::PartialEq<
-                        bevy::math::primitives::Segment3d,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |direction: Val<bevy::math::prelude::Dir3>, length: f32| {
-                    let output: Val<bevy::math::primitives::Segment3d> = bevy::math::primitives::Segment3d::new(
-                            direction.into_inner(),
-                            length,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "point1",
-                |_self: Ref<bevy::math::primitives::Segment3d>| {
-                    let output: Val<bevy::math::prelude::Vec3> = bevy::math::primitives::Segment3d::point1(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "point2",
-                |_self: Ref<bevy::math::primitives::Segment3d>| {
-                    let output: Val<bevy::math::prelude::Vec3> = bevy::math::primitives::Segment3d::point2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Torus>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Torus>| {
-                    let output: Val<bevy::math::primitives::Torus> = <bevy::math::primitives::Torus as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Torus>,
-                    other: Ref<bevy::math::primitives::Torus>|
-                {
-                    let output: bool = <bevy::math::primitives::Torus as std::cmp::PartialEq<
-                        bevy::math::primitives::Torus,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inner_radius",
-                |_self: Ref<bevy::math::primitives::Torus>| {
-                    let output: f32 = bevy::math::primitives::Torus::inner_radius(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |inner_radius: f32, outer_radius: f32| {
-                    let output: Val<bevy::math::primitives::Torus> = bevy::math::primitives::Torus::new(
-                            inner_radius,
-                            outer_radius,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "outer_radius",
-                |_self: Ref<bevy::math::primitives::Torus>| {
-                    let output: f32 = bevy::math::primitives::Torus::outer_radius(&_self)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Triangle3d>::new(world)
-            .register(
-                "centroid",
-                |_self: Ref<bevy::math::primitives::Triangle3d>| {
-                    let output: Val<bevy::math::prelude::Vec3> = bevy::math::primitives::Triangle3d::centroid(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "circumcenter",
-                |_self: Ref<bevy::math::primitives::Triangle3d>| {
-                    let output: Val<bevy::math::prelude::Vec3> = bevy::math::primitives::Triangle3d::circumcenter(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Triangle3d>| {
-                    let output: Val<bevy::math::primitives::Triangle3d> = <bevy::math::primitives::Triangle3d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Triangle3d>,
-                    other: Ref<bevy::math::primitives::Triangle3d>|
-                {
-                    let output: bool = <bevy::math::primitives::Triangle3d as std::cmp::PartialEq<
-                        bevy::math::primitives::Triangle3d,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_acute",
-                |_self: Ref<bevy::math::primitives::Triangle3d>| {
-                    let output: bool = bevy::math::primitives::Triangle3d::is_acute(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_degenerate",
-                |_self: Ref<bevy::math::primitives::Triangle3d>| {
-                    let output: bool = bevy::math::primitives::Triangle3d::is_degenerate(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_obtuse",
-                |_self: Ref<bevy::math::primitives::Triangle3d>| {
-                    let output: bool = bevy::math::primitives::Triangle3d::is_obtuse(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |
-                    a: Val<bevy::math::prelude::Vec3>,
-                    b: Val<bevy::math::prelude::Vec3>,
-                    c: Val<bevy::math::prelude::Vec3>|
-                {
-                    let output: Val<bevy::math::primitives::Triangle3d> = bevy::math::primitives::Triangle3d::new(
-                            a.into_inner(),
-                            b.into_inner(),
-                            c.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reverse",
-                |mut _self: Mut<bevy::math::primitives::Triangle3d>| {
-                    let output: () = bevy::math::primitives::Triangle3d::reverse(
-                            &mut _self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reversed",
-                |_self: Val<bevy::math::primitives::Triangle3d>| {
-                    let output: Val<bevy::math::primitives::Triangle3d> = bevy::math::primitives::Triangle3d::reversed(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::bounding::RayCast2d>::new(world)
-            .register(
-                "aabb_intersection_at",
-                |
-                    _self: Ref<bevy::math::bounding::RayCast2d>,
-                    aabb: Ref<bevy::math::bounding::Aabb2d>|
-                {
-                    let output: std::option::Option<f32> = bevy::math::bounding::RayCast2d::aabb_intersection_at(
-                            &_self,
-                            &aabb,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "circle_intersection_at",
-                |
-                    _self: Ref<bevy::math::bounding::RayCast2d>,
-                    circle: Ref<bevy::math::bounding::BoundingCircle>|
-                {
-                    let output: std::option::Option<f32> = bevy::math::bounding::RayCast2d::circle_intersection_at(
-                            &_self,
-                            &circle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::bounding::RayCast2d>| {
-                    let output: Val<bevy::math::bounding::RayCast2d> = <bevy::math::bounding::RayCast2d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "direction_recip",
-                |_self: Ref<bevy::math::bounding::RayCast2d>| {
-                    let output: Val<bevy::math::prelude::Vec2> = bevy::math::bounding::RayCast2d::direction_recip(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_ray",
-                |ray: Val<bevy::math::Ray2d>, max: f32| {
-                    let output: Val<bevy::math::bounding::RayCast2d> = bevy::math::bounding::RayCast2d::from_ray(
-                            ray.into_inner(),
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |
-                    origin: Val<bevy::math::prelude::Vec2>,
-                    direction: Val<bevy::math::prelude::Dir2>,
-                    max: f32|
-                {
-                    let output: Val<bevy::math::bounding::RayCast2d> = bevy::math::bounding::RayCast2d::new(
-                            origin.into_inner(),
-                            direction.into_inner(),
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::bounding::AabbCast2d>::new(world)
-            .register(
-                "aabb_collision_at",
-                |
-                    _self: Ref<bevy::math::bounding::AabbCast2d>,
-                    aabb: Val<bevy::math::bounding::Aabb2d>|
-                {
-                    let output: std::option::Option<f32> = bevy::math::bounding::AabbCast2d::aabb_collision_at(
-                            &_self,
-                            aabb.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::bounding::AabbCast2d>| {
-                    let output: Val<bevy::math::bounding::AabbCast2d> = <bevy::math::bounding::AabbCast2d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_ray",
-                |
-                    aabb: Val<bevy::math::bounding::Aabb2d>,
-                    ray: Val<bevy::math::Ray2d>,
-                    max: f32|
-                {
-                    let output: Val<bevy::math::bounding::AabbCast2d> = bevy::math::bounding::AabbCast2d::from_ray(
-                            aabb.into_inner(),
-                            ray.into_inner(),
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |
-                    aabb: Val<bevy::math::bounding::Aabb2d>,
-                    origin: Val<bevy::math::prelude::Vec2>,
-                    direction: Val<bevy::math::prelude::Dir2>,
-                    max: f32|
-                {
-                    let output: Val<bevy::math::bounding::AabbCast2d> = bevy::math::bounding::AabbCast2d::new(
-                            aabb.into_inner(),
-                            origin.into_inner(),
-                            direction.into_inner(),
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::bounding::BoundingCircleCast>::new(world)
-            .register(
-                "circle_collision_at",
-                |
-                    _self: Ref<bevy::math::bounding::BoundingCircleCast>,
-                    circle: Val<bevy::math::bounding::BoundingCircle>|
-                {
-                    let output: std::option::Option<f32> = bevy::math::bounding::BoundingCircleCast::circle_collision_at(
-                            &_self,
-                            circle.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::bounding::BoundingCircleCast>| {
-                    let output: Val<bevy::math::bounding::BoundingCircleCast> = <bevy::math::bounding::BoundingCircleCast as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_ray",
-                |
-                    circle: Val<bevy::math::bounding::BoundingCircle>,
-                    ray: Val<bevy::math::Ray2d>,
-                    max: f32|
-                {
-                    let output: Val<bevy::math::bounding::BoundingCircleCast> = bevy::math::bounding::BoundingCircleCast::from_ray(
-                            circle.into_inner(),
-                            ray.into_inner(),
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |
-                    circle: Val<bevy::math::bounding::BoundingCircle>,
-                    origin: Val<bevy::math::prelude::Vec2>,
-                    direction: Val<bevy::math::prelude::Dir2>,
-                    max: f32|
-                {
-                    let output: Val<bevy::math::bounding::BoundingCircleCast> = bevy::math::bounding::BoundingCircleCast::new(
-                            circle.into_inner(),
-                            origin.into_inner(),
-                            direction.into_inner(),
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::bounding::RayCast3d>::new(world)
-            .register(
-                "aabb_intersection_at",
-                |
-                    _self: Ref<bevy::math::bounding::RayCast3d>,
-                    aabb: Ref<bevy::math::bounding::Aabb3d>|
-                {
-                    let output: std::option::Option<f32> = bevy::math::bounding::RayCast3d::aabb_intersection_at(
-                            &_self,
-                            &aabb,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::bounding::RayCast3d>| {
-                    let output: Val<bevy::math::bounding::RayCast3d> = <bevy::math::bounding::RayCast3d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "direction_recip",
-                |_self: Ref<bevy::math::bounding::RayCast3d>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::bounding::RayCast3d::direction_recip(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_ray",
-                |ray: Val<bevy::math::Ray3d>, max: f32| {
-                    let output: Val<bevy::math::bounding::RayCast3d> = bevy::math::bounding::RayCast3d::from_ray(
-                            ray.into_inner(),
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sphere_intersection_at",
-                |
-                    _self: Ref<bevy::math::bounding::RayCast3d>,
-                    sphere: Ref<bevy::math::bounding::BoundingSphere>|
-                {
-                    let output: std::option::Option<f32> = bevy::math::bounding::RayCast3d::sphere_intersection_at(
-                            &_self,
-                            &sphere,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::bounding::AabbCast3d>::new(world)
-            .register(
-                "aabb_collision_at",
-                |
-                    _self: Ref<bevy::math::bounding::AabbCast3d>,
-                    aabb: Val<bevy::math::bounding::Aabb3d>|
-                {
-                    let output: std::option::Option<f32> = bevy::math::bounding::AabbCast3d::aabb_collision_at(
-                            &_self,
-                            aabb.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::bounding::AabbCast3d>| {
-                    let output: Val<bevy::math::bounding::AabbCast3d> = <bevy::math::bounding::AabbCast3d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_ray",
-                |
-                    aabb: Val<bevy::math::bounding::Aabb3d>,
-                    ray: Val<bevy::math::Ray3d>,
-                    max: f32|
-                {
-                    let output: Val<bevy::math::bounding::AabbCast3d> = bevy::math::bounding::AabbCast3d::from_ray(
-                            aabb.into_inner(),
-                            ray.into_inner(),
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::bounding::BoundingSphereCast>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::bounding::BoundingSphereCast>| {
-                    let output: Val<bevy::math::bounding::BoundingSphereCast> = <bevy::math::bounding::BoundingSphereCast as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_ray",
-                |
-                    sphere: Val<bevy::math::bounding::BoundingSphere>,
-                    ray: Val<bevy::math::Ray3d>,
-                    max: f32|
-                {
-                    let output: Val<bevy::math::bounding::BoundingSphereCast> = bevy::math::bounding::BoundingSphereCast::from_ray(
-                            sphere.into_inner(),
-                            ray.into_inner(),
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sphere_collision_at",
-                |
-                    _self: Ref<bevy::math::bounding::BoundingSphereCast>,
-                    sphere: Val<bevy::math::bounding::BoundingSphere>|
-                {
-                    let output: std::option::Option<f32> = bevy::math::bounding::BoundingSphereCast::sphere_collision_at(
-                            &_self,
-                            sphere.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::curve::interval::Interval>::new(world)
-            .register(
-                "clamp",
-                |_self: Val<bevy::math::curve::interval::Interval>, value: f32| {
-                    let output: f32 = bevy::math::curve::interval::Interval::clamp(
-                            _self.into_inner(),
-                            value,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::curve::interval::Interval>| {
-                    let output: Val<bevy::math::curve::interval::Interval> = <bevy::math::curve::interval::Interval as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "contains",
-                |_self: Val<bevy::math::curve::interval::Interval>, item: f32| {
-                    let output: bool = bevy::math::curve::interval::Interval::contains(
-                            _self.into_inner(),
-                            item,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "contains_interval",
-                |
-                    _self: Val<bevy::math::curve::interval::Interval>,
-                    other: Val<bevy::math::curve::interval::Interval>|
-                {
-                    let output: bool = bevy::math::curve::interval::Interval::contains_interval(
-                            _self.into_inner(),
-                            other.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "end",
-                |_self: Val<bevy::math::curve::interval::Interval>| {
-                    let output: f32 = bevy::math::curve::interval::Interval::end(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::curve::interval::Interval>,
-                    other: Ref<bevy::math::curve::interval::Interval>|
-                {
-                    let output: bool = <bevy::math::curve::interval::Interval as std::cmp::PartialEq<
-                        bevy::math::curve::interval::Interval,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "has_finite_end",
-                |_self: Val<bevy::math::curve::interval::Interval>| {
-                    let output: bool = bevy::math::curve::interval::Interval::has_finite_end(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "has_finite_start",
-                |_self: Val<bevy::math::curve::interval::Interval>| {
-                    let output: bool = bevy::math::curve::interval::Interval::has_finite_start(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_bounded",
-                |_self: Val<bevy::math::curve::interval::Interval>| {
-                    let output: bool = bevy::math::curve::interval::Interval::is_bounded(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length",
-                |_self: Val<bevy::math::curve::interval::Interval>| {
-                    let output: f32 = bevy::math::curve::interval::Interval::length(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "start",
-                |_self: Val<bevy::math::curve::interval::Interval>| {
-                    let output: f32 = bevy::math::curve::interval::Interval::start(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::FloatOrd>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::FloatOrd>| {
-                    let output: Val<bevy::math::FloatOrd> = <bevy::math::FloatOrd as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::FloatOrd>, other: Ref<bevy::math::FloatOrd>| {
-                    let output: bool = <bevy::math::FloatOrd as std::cmp::PartialEq<
-                        bevy::math::FloatOrd,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "ge",
-                |_self: Ref<bevy::math::FloatOrd>, other: Ref<bevy::math::FloatOrd>| {
-                    let output: bool = <bevy::math::FloatOrd as std::cmp::PartialOrd<
-                        bevy::math::FloatOrd,
-                    >>::ge(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "gt",
-                |_self: Ref<bevy::math::FloatOrd>, other: Ref<bevy::math::FloatOrd>| {
-                    let output: bool = <bevy::math::FloatOrd as std::cmp::PartialOrd<
-                        bevy::math::FloatOrd,
-                    >>::gt(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "le",
-                |_self: Ref<bevy::math::FloatOrd>, other: Ref<bevy::math::FloatOrd>| {
-                    let output: bool = <bevy::math::FloatOrd as std::cmp::PartialOrd<
-                        bevy::math::FloatOrd,
-                    >>::le(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "lt",
-                |_self: Ref<bevy::math::FloatOrd>, other: Ref<bevy::math::FloatOrd>| {
-                    let output: bool = <bevy::math::FloatOrd as std::cmp::PartialOrd<
-                        bevy::math::FloatOrd,
-                    >>::lt(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::FloatOrd>| {
-                    let output: Val<bevy::math::FloatOrd> = <bevy::math::FloatOrd as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Plane3d>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Plane3d>| {
-                    let output: Val<bevy::math::primitives::Plane3d> = <bevy::math::primitives::Plane3d as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Plane3d>,
-                    other: Ref<bevy::math::primitives::Plane3d>|
-                {
-                    let output: bool = <bevy::math::primitives::Plane3d as std::cmp::PartialEq<
-                        bevy::math::primitives::Plane3d,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |
-                    normal: Val<bevy::math::prelude::Vec3>,
-                    half_size: Val<bevy::math::prelude::Vec2>|
-                {
-                    let output: Val<bevy::math::primitives::Plane3d> = bevy::math::primitives::Plane3d::new(
-                            normal.into_inner(),
-                            half_size.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::primitives::Tetrahedron>::new(world)
-            .register(
-                "centroid",
-                |_self: Ref<bevy::math::primitives::Tetrahedron>| {
-                    let output: Val<bevy::math::prelude::Vec3> = bevy::math::primitives::Tetrahedron::centroid(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::primitives::Tetrahedron>| {
-                    let output: Val<bevy::math::primitives::Tetrahedron> = <bevy::math::primitives::Tetrahedron as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::primitives::Tetrahedron>,
-                    other: Ref<bevy::math::primitives::Tetrahedron>|
-                {
-                    let output: bool = <bevy::math::primitives::Tetrahedron as std::cmp::PartialEq<
-                        bevy::math::primitives::Tetrahedron,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |
-                    a: Val<bevy::math::prelude::Vec3>,
-                    b: Val<bevy::math::prelude::Vec3>,
-                    c: Val<bevy::math::prelude::Vec3>,
-                    d: Val<bevy::math::prelude::Vec3>|
-                {
-                    let output: Val<bevy::math::primitives::Tetrahedron> = bevy::math::primitives::Tetrahedron::new(
-                            a.into_inner(),
-                            b.into_inner(),
-                            c.into_inner(),
-                            d.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "signed_volume",
-                |_self: Ref<bevy::math::primitives::Tetrahedron>| {
-                    let output: f32 = bevy::math::primitives::Tetrahedron::signed_volume(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::curve::easing::EaseFunction>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::curve::easing::EaseFunction>| {
-                    let output: Val<bevy::math::curve::easing::EaseFunction> = <bevy::math::curve::easing::EaseFunction as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::math::curve::easing::EaseFunction>,
-                    other: Ref<bevy::math::curve::easing::EaseFunction>|
-                {
-                    let output: bool = <bevy::math::curve::easing::EaseFunction as std::cmp::PartialEq<
-                        bevy::math::curve::easing::EaseFunction,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
+        register_aspect_ratio(&mut world);
+        register_compass_octant(&mut world);
+        register_compass_quadrant(&mut world);
+        register_isometry_2_d(&mut world);
+        register_isometry_3_d(&mut world);
+        register_ray_2_d(&mut world);
+        register_ray_3_d(&mut world);
+        register_rot_2(&mut world);
+        register_dir_2(&mut world);
+        register_dir_3(&mut world);
+        register_dir_3_a(&mut world);
+        register_i_rect(&mut world);
+        register_rect(&mut world);
+        register_u_rect(&mut world);
+        register_affine_3(&mut world);
+        register_aabb_2_d(&mut world);
+        register_bounding_circle(&mut world);
+        register_circle(&mut world);
+        register_annulus(&mut world);
+        register_arc_2_d(&mut world);
+        register_capsule_2_d(&mut world);
+        register_circular_sector(&mut world);
+        register_circular_segment(&mut world);
+        register_ellipse(&mut world);
+        register_line_2_d(&mut world);
+        register_plane_2_d(&mut world);
+        register_rectangle(&mut world);
+        register_regular_polygon(&mut world);
+        register_rhombus(&mut world);
+        register_segment_2_d(&mut world);
+        register_triangle_2_d(&mut world);
+        register_aabb_3_d(&mut world);
+        register_bounding_sphere(&mut world);
+        register_sphere(&mut world);
+        register_cuboid(&mut world);
+        register_cylinder(&mut world);
+        register_capsule_3_d(&mut world);
+        register_cone(&mut world);
+        register_conical_frustum(&mut world);
+        register_infinite_plane_3_d(&mut world);
+        register_line_3_d(&mut world);
+        register_segment_3_d(&mut world);
+        register_torus(&mut world);
+        register_triangle_3_d(&mut world);
+        register_ray_cast_2_d(&mut world);
+        register_aabb_cast_2_d(&mut world);
+        register_bounding_circle_cast(&mut world);
+        register_ray_cast_3_d(&mut world);
+        register_aabb_cast_3_d(&mut world);
+        register_bounding_sphere_cast(&mut world);
+        register_interval(&mut world);
+        register_float_ord(&mut world);
+        register_plane_3_d(&mut world);
+        register_tetrahedron(&mut world);
+        register_ease_function(&mut world);
     }
 }
diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_reflect.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_reflect.rs
index bd06a19b80..6d72171c8d 100644
--- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_reflect.rs
+++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_reflect.rs
@@ -9,22060 +9,14795 @@ use bevy_mod_scripting_core::bindings::{
         namespace::NamespaceBuilder,
     },
 };
+use bevy_mod_scripting_derive::script_bindings;
 use crate::*;
 pub struct BevyReflectScriptingPlugin;
+#[script_bindings(remote, name = "atomic_bool")]
+impl std::sync::atomic::AtomicBool {
+    fn into_inner(_self: Val<std::sync::atomic::AtomicBool>) {
+        let output: bool = std::sync::atomic::AtomicBool::into_inner(_self.into_inner())
+            .into();
+        output
+    }
+    fn new(v: bool) {
+        let output: Val<std::sync::atomic::AtomicBool> = std::sync::atomic::AtomicBool::new(
+                v,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "atomic_i_16")]
+impl std::sync::atomic::AtomicI16 {
+    fn into_inner(_self: Val<std::sync::atomic::AtomicI16>) {
+        let output: i16 = std::sync::atomic::AtomicI16::into_inner(_self.into_inner())
+            .into();
+        output
+    }
+    fn new(v: i16) {
+        let output: Val<std::sync::atomic::AtomicI16> = std::sync::atomic::AtomicI16::new(
+                v,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "atomic_i_32")]
+impl std::sync::atomic::AtomicI32 {
+    fn into_inner(_self: Val<std::sync::atomic::AtomicI32>) {
+        let output: i32 = std::sync::atomic::AtomicI32::into_inner(_self.into_inner())
+            .into();
+        output
+    }
+    fn new(v: i32) {
+        let output: Val<std::sync::atomic::AtomicI32> = std::sync::atomic::AtomicI32::new(
+                v,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "atomic_i_64")]
+impl std::sync::atomic::AtomicI64 {
+    fn into_inner(_self: Val<std::sync::atomic::AtomicI64>) {
+        let output: i64 = std::sync::atomic::AtomicI64::into_inner(_self.into_inner())
+            .into();
+        output
+    }
+    fn new(v: i64) {
+        let output: Val<std::sync::atomic::AtomicI64> = std::sync::atomic::AtomicI64::new(
+                v,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "atomic_i_8")]
+impl std::sync::atomic::AtomicI8 {
+    fn into_inner(_self: Val<std::sync::atomic::AtomicI8>) {
+        let output: i8 = std::sync::atomic::AtomicI8::into_inner(_self.into_inner())
+            .into();
+        output
+    }
+    fn new(v: i8) {
+        let output: Val<std::sync::atomic::AtomicI8> = std::sync::atomic::AtomicI8::new(
+                v,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "atomic_isize")]
+impl std::sync::atomic::AtomicIsize {
+    fn into_inner(_self: Val<std::sync::atomic::AtomicIsize>) {
+        let output: isize = std::sync::atomic::AtomicIsize::into_inner(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(v: isize) {
+        let output: Val<std::sync::atomic::AtomicIsize> = std::sync::atomic::AtomicIsize::new(
+                v,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "atomic_u_16")]
+impl std::sync::atomic::AtomicU16 {
+    fn into_inner(_self: Val<std::sync::atomic::AtomicU16>) {
+        let output: u16 = std::sync::atomic::AtomicU16::into_inner(_self.into_inner())
+            .into();
+        output
+    }
+    fn new(v: u16) {
+        let output: Val<std::sync::atomic::AtomicU16> = std::sync::atomic::AtomicU16::new(
+                v,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "atomic_u_32")]
+impl std::sync::atomic::AtomicU32 {
+    fn into_inner(_self: Val<std::sync::atomic::AtomicU32>) {
+        let output: u32 = std::sync::atomic::AtomicU32::into_inner(_self.into_inner())
+            .into();
+        output
+    }
+    fn new(v: u32) {
+        let output: Val<std::sync::atomic::AtomicU32> = std::sync::atomic::AtomicU32::new(
+                v,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "atomic_u_64")]
+impl std::sync::atomic::AtomicU64 {
+    fn into_inner(_self: Val<std::sync::atomic::AtomicU64>) {
+        let output: u64 = std::sync::atomic::AtomicU64::into_inner(_self.into_inner())
+            .into();
+        output
+    }
+    fn new(v: u64) {
+        let output: Val<std::sync::atomic::AtomicU64> = std::sync::atomic::AtomicU64::new(
+                v,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "atomic_u_8")]
+impl std::sync::atomic::AtomicU8 {
+    fn into_inner(_self: Val<std::sync::atomic::AtomicU8>) {
+        let output: u8 = std::sync::atomic::AtomicU8::into_inner(_self.into_inner())
+            .into();
+        output
+    }
+    fn new(v: u8) {
+        let output: Val<std::sync::atomic::AtomicU8> = std::sync::atomic::AtomicU8::new(
+                v,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "atomic_usize")]
+impl std::sync::atomic::AtomicUsize {
+    fn into_inner(_self: Val<std::sync::atomic::AtomicUsize>) {
+        let output: usize = std::sync::atomic::AtomicUsize::into_inner(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(v: usize) {
+        let output: Val<std::sync::atomic::AtomicUsize> = std::sync::atomic::AtomicUsize::new(
+                v,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "duration")]
+impl bevy::utils::Duration {
+    fn abs_diff(_self: Val<bevy::utils::Duration>, other: Val<bevy::utils::Duration>) {
+        let output: Val<bevy::utils::Duration> = bevy::utils::Duration::abs_diff(
+                _self.into_inner(),
+                other.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::utils::Duration>, rhs: Val<bevy::utils::Duration>) {
+        let output: Val<bevy::utils::Duration> = <bevy::utils::Duration as std::ops::Add<
+            bevy::utils::Duration,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn as_micros(_self: Ref<bevy::utils::Duration>) {
+        let output: u128 = bevy::utils::Duration::as_micros(&_self).into();
+        output
+    }
+    fn as_millis(_self: Ref<bevy::utils::Duration>) {
+        let output: u128 = bevy::utils::Duration::as_millis(&_self).into();
+        output
+    }
+    fn as_nanos(_self: Ref<bevy::utils::Duration>) {
+        let output: u128 = bevy::utils::Duration::as_nanos(&_self).into();
+        output
+    }
+    fn as_secs(_self: Ref<bevy::utils::Duration>) {
+        let output: u64 = bevy::utils::Duration::as_secs(&_self).into();
+        output
+    }
+    fn as_secs_f32(_self: Ref<bevy::utils::Duration>) {
+        let output: f32 = bevy::utils::Duration::as_secs_f32(&_self).into();
+        output
+    }
+    fn as_secs_f64(_self: Ref<bevy::utils::Duration>) {
+        let output: f64 = bevy::utils::Duration::as_secs_f64(&_self).into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::utils::Duration>) {
+        let output: () = <bevy::utils::Duration as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::utils::Duration>) {
+        let output: Val<bevy::utils::Duration> = <bevy::utils::Duration as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::utils::Duration>, rhs: u32) {
+        let output: Val<bevy::utils::Duration> = <bevy::utils::Duration as std::ops::Div<
+            u32,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_duration_f32(
+        _self: Val<bevy::utils::Duration>,
+        rhs: Val<bevy::utils::Duration>,
+    ) {
+        let output: f32 = bevy::utils::Duration::div_duration_f32(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div_duration_f64(
+        _self: Val<bevy::utils::Duration>,
+        rhs: Val<bevy::utils::Duration>,
+    ) {
+        let output: f64 = bevy::utils::Duration::div_duration_f64(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div_f32(_self: Val<bevy::utils::Duration>, rhs: f32) {
+        let output: Val<bevy::utils::Duration> = bevy::utils::Duration::div_f32(
+                _self.into_inner(),
+                rhs,
+            )
+            .into();
+        output
+    }
+    fn div_f64(_self: Val<bevy::utils::Duration>, rhs: f64) {
+        let output: Val<bevy::utils::Duration> = bevy::utils::Duration::div_f64(
+                _self.into_inner(),
+                rhs,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::utils::Duration>, other: Ref<bevy::utils::Duration>) {
+        let output: bool = <bevy::utils::Duration as std::cmp::PartialEq<
+            bevy::utils::Duration,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_micros(micros: u64) {
+        let output: Val<bevy::utils::Duration> = bevy::utils::Duration::from_micros(
+                micros,
+            )
+            .into();
+        output
+    }
+    fn from_millis(millis: u64) {
+        let output: Val<bevy::utils::Duration> = bevy::utils::Duration::from_millis(
+                millis,
+            )
+            .into();
+        output
+    }
+    fn from_nanos(nanos: u64) {
+        let output: Val<bevy::utils::Duration> = bevy::utils::Duration::from_nanos(nanos)
+            .into();
+        output
+    }
+    fn from_secs(secs: u64) {
+        let output: Val<bevy::utils::Duration> = bevy::utils::Duration::from_secs(secs)
+            .into();
+        output
+    }
+    fn from_secs_f32(secs: f32) {
+        let output: Val<bevy::utils::Duration> = bevy::utils::Duration::from_secs_f32(
+                secs,
+            )
+            .into();
+        output
+    }
+    fn from_secs_f64(secs: f64) {
+        let output: Val<bevy::utils::Duration> = bevy::utils::Duration::from_secs_f64(
+                secs,
+            )
+            .into();
+        output
+    }
+    fn is_zero(_self: Ref<bevy::utils::Duration>) {
+        let output: bool = bevy::utils::Duration::is_zero(&_self).into();
+        output
+    }
+    fn mul(_self: Val<bevy::utils::Duration>, rhs: u32) {
+        let output: Val<bevy::utils::Duration> = <bevy::utils::Duration as std::ops::Mul<
+            u32,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn mul_f32(_self: Val<bevy::utils::Duration>, rhs: f32) {
+        let output: Val<bevy::utils::Duration> = bevy::utils::Duration::mul_f32(
+                _self.into_inner(),
+                rhs,
+            )
+            .into();
+        output
+    }
+    fn mul_f64(_self: Val<bevy::utils::Duration>, rhs: f64) {
+        let output: Val<bevy::utils::Duration> = bevy::utils::Duration::mul_f64(
+                _self.into_inner(),
+                rhs,
+            )
+            .into();
+        output
+    }
+    fn new(secs: u64, nanos: u32) {
+        let output: Val<bevy::utils::Duration> = bevy::utils::Duration::new(secs, nanos)
+            .into();
+        output
+    }
+    fn saturating_add(
+        _self: Val<bevy::utils::Duration>,
+        rhs: Val<bevy::utils::Duration>,
+    ) {
+        let output: Val<bevy::utils::Duration> = bevy::utils::Duration::saturating_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_mul(_self: Val<bevy::utils::Duration>, rhs: u32) {
+        let output: Val<bevy::utils::Duration> = bevy::utils::Duration::saturating_mul(
+                _self.into_inner(),
+                rhs,
+            )
+            .into();
+        output
+    }
+    fn saturating_sub(
+        _self: Val<bevy::utils::Duration>,
+        rhs: Val<bevy::utils::Duration>,
+    ) {
+        let output: Val<bevy::utils::Duration> = bevy::utils::Duration::saturating_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::utils::Duration>, rhs: Val<bevy::utils::Duration>) {
+        let output: Val<bevy::utils::Duration> = <bevy::utils::Duration as std::ops::Sub<
+            bevy::utils::Duration,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn subsec_micros(_self: Ref<bevy::utils::Duration>) {
+        let output: u32 = bevy::utils::Duration::subsec_micros(&_self).into();
+        output
+    }
+    fn subsec_millis(_self: Ref<bevy::utils::Duration>) {
+        let output: u32 = bevy::utils::Duration::subsec_millis(&_self).into();
+        output
+    }
+    fn subsec_nanos(_self: Ref<bevy::utils::Duration>) {
+        let output: u32 = bevy::utils::Duration::subsec_nanos(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "instant")]
+impl bevy::utils::Instant {
+    fn add(_self: Val<bevy::utils::Instant>, other: Val<bevy::utils::Duration>) {
+        let output: Val<bevy::utils::Instant> = <bevy::utils::Instant as std::ops::Add<
+            bevy::utils::Duration,
+        >>::add(_self.into_inner(), other.into_inner())
+            .into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::utils::Instant>) {
+        let output: () = <bevy::utils::Instant as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::utils::Instant>) {
+        let output: Val<bevy::utils::Instant> = <bevy::utils::Instant as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn duration_since(
+        _self: Ref<bevy::utils::Instant>,
+        earlier: Val<bevy::utils::Instant>,
+    ) {
+        let output: Val<bevy::utils::Duration> = bevy::utils::Instant::duration_since(
+                &_self,
+                earlier.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn elapsed(_self: Ref<bevy::utils::Instant>) {
+        let output: Val<bevy::utils::Duration> = bevy::utils::Instant::elapsed(&_self)
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::utils::Instant>, other: Ref<bevy::utils::Instant>) {
+        let output: bool = <bevy::utils::Instant as std::cmp::PartialEq<
+            bevy::utils::Instant,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn now() {
+        let output: Val<bevy::utils::Instant> = bevy::utils::Instant::now().into();
+        output
+    }
+    fn saturating_duration_since(
+        _self: Ref<bevy::utils::Instant>,
+        earlier: Val<bevy::utils::Instant>,
+    ) {
+        let output: Val<bevy::utils::Duration> = bevy::utils::Instant::saturating_duration_since(
+                &_self,
+                earlier.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::utils::Instant>, other: Val<bevy::utils::Duration>) {
+        let output: Val<bevy::utils::Instant> = <bevy::utils::Instant as std::ops::Sub<
+            bevy::utils::Duration,
+        >>::sub(_self.into_inner(), other.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::utils::Instant>, other: Val<bevy::utils::Instant>) {
+        let output: Val<bevy::utils::Duration> = <bevy::utils::Instant as std::ops::Sub<
+            bevy::utils::Instant,
+        >>::sub(_self.into_inner(), other.into_inner())
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "range_full")]
+impl std::ops::RangeFull {
+    fn assert_receiver_is_total_eq(_self: Ref<std::ops::RangeFull>) {
+        let output: () = <std::ops::RangeFull as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<std::ops::RangeFull>) {
+        let output: Val<std::ops::RangeFull> = <std::ops::RangeFull as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<std::ops::RangeFull>, other: Ref<std::ops::RangeFull>) {
+        let output: bool = <std::ops::RangeFull as std::cmp::PartialEq<
+            std::ops::RangeFull,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "quat")]
+impl bevy::math::Quat {
+    fn abs_diff_eq(
+        _self: Val<bevy::math::Quat>,
+        rhs: Val<bevy::math::Quat>,
+        max_abs_diff: f32,
+    ) {
+        let output: bool = bevy::math::Quat::abs_diff_eq(
+                _self.into_inner(),
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Quat>) {
+        let output: Val<bevy::math::Quat> = <bevy::math::Quat as std::ops::Add<
+            bevy::math::Quat,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn angle_between(_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Quat>) {
+        let output: f32 = bevy::math::Quat::angle_between(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn as_dquat(_self: Val<bevy::math::Quat>) {
+        let output: Val<bevy::math::DQuat> = bevy::math::Quat::as_dquat(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::Quat>) {
+        let output: Val<bevy::math::Quat> = <bevy::math::Quat as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn conjugate(_self: Val<bevy::math::Quat>) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::conjugate(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::Quat>, rhs: f32) {
+        let output: Val<bevy::math::Quat> = <bevy::math::Quat as std::ops::Div<
+            f32,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Quat>) {
+        let output: f32 = bevy::math::Quat::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::Quat>, rhs: Ref<bevy::math::Quat>) {
+        let output: bool = <bevy::math::Quat as std::cmp::PartialEq<
+            bevy::math::Quat,
+        >>::eq(&_self, &rhs)
+            .into();
+        output
+    }
+    fn from_affine3(a: Ref<bevy::math::Affine3A>) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::from_affine3(&a).into();
+        output
+    }
+    fn from_array(a: [f32; 4]) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::from_array(a).into();
+        output
+    }
+    fn from_axis_angle(axis: Val<bevy::math::Vec3>, angle: f32) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::from_axis_angle(
+                axis.into_inner(),
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_euler(euler: Val<bevy::math::EulerRot>, a: f32, b: f32, c: f32) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::from_euler(
+                euler.into_inner(),
+                a,
+                b,
+                c,
+            )
+            .into();
+        output
+    }
+    fn from_mat3(mat: Ref<bevy::math::Mat3>) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::from_mat3(&mat).into();
+        output
+    }
+    fn from_mat3a(mat: Ref<bevy::math::Mat3A>) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::from_mat3a(&mat).into();
+        output
+    }
+    fn from_mat4(mat: Ref<bevy::math::Mat4>) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::from_mat4(&mat).into();
+        output
+    }
+    fn from_rotation_arc(from: Val<bevy::math::Vec3>, to: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::from_rotation_arc(
+                from.into_inner(),
+                to.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_rotation_arc_2d(from: Val<bevy::math::Vec2>, to: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::from_rotation_arc_2d(
+                from.into_inner(),
+                to.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_rotation_arc_colinear(
+        from: Val<bevy::math::Vec3>,
+        to: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::from_rotation_arc_colinear(
+                from.into_inner(),
+                to.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_rotation_x(angle: f32) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::from_rotation_x(angle)
+            .into();
+        output
+    }
+    fn from_rotation_y(angle: f32) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::from_rotation_y(angle)
+            .into();
+        output
+    }
+    fn from_rotation_z(angle: f32) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::from_rotation_z(angle)
+            .into();
+        output
+    }
+    fn from_scaled_axis(v: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::from_scaled_axis(
+                v.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_vec4(v: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::from_vec4(v.into_inner())
+            .into();
+        output
+    }
+    fn from_xyzw(x: f32, y: f32, z: f32, w: f32) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::from_xyzw(x, y, z, w)
+            .into();
+        output
+    }
+    fn inverse(_self: Val<bevy::math::Quat>) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::inverse(_self.into_inner())
+            .into();
+        output
+    }
+    fn is_finite(_self: Val<bevy::math::Quat>) {
+        let output: bool = bevy::math::Quat::is_finite(_self.into_inner()).into();
+        output
+    }
+    fn is_nan(_self: Val<bevy::math::Quat>) {
+        let output: bool = bevy::math::Quat::is_nan(_self.into_inner()).into();
+        output
+    }
+    fn is_near_identity(_self: Val<bevy::math::Quat>) {
+        let output: bool = bevy::math::Quat::is_near_identity(_self.into_inner()).into();
+        output
+    }
+    fn is_normalized(_self: Val<bevy::math::Quat>) {
+        let output: bool = bevy::math::Quat::is_normalized(_self.into_inner()).into();
+        output
+    }
+    fn length(_self: Val<bevy::math::Quat>) {
+        let output: f32 = bevy::math::Quat::length(_self.into_inner()).into();
+        output
+    }
+    fn length_recip(_self: Val<bevy::math::Quat>) {
+        let output: f32 = bevy::math::Quat::length_recip(_self.into_inner()).into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::Quat>) {
+        let output: f32 = bevy::math::Quat::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn lerp(_self: Val<bevy::math::Quat>, end: Val<bevy::math::Quat>, s: f32) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::lerp(
+                _self.into_inner(),
+                end.into_inner(),
+                s,
+            )
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Quat>) {
+        let output: Val<bevy::math::Quat> = <bevy::math::Quat as std::ops::Mul<
+            bevy::math::Quat,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Quat as std::ops::Mul<
+            bevy::math::Vec3,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Quat as std::ops::Mul<
+            bevy::math::Vec3A,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Quat>, rhs: f32) {
+        let output: Val<bevy::math::Quat> = <bevy::math::Quat as std::ops::Mul<
+            f32,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn mul_quat(_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Quat>) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::mul_quat(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn mul_vec3(_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Quat::mul_vec3(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn mul_vec3a(_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Quat::mul_vec3a(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::Quat>) {
+        let output: Val<bevy::math::Quat> = <bevy::math::Quat as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn normalize(_self: Val<bevy::math::Quat>) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::normalize(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rotate_towards(
+        _self: Ref<bevy::math::Quat>,
+        rhs: Val<bevy::math::Quat>,
+        max_angle: f32,
+    ) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::rotate_towards(
+                &_self,
+                rhs.into_inner(),
+                max_angle,
+            )
+            .into();
+        output
+    }
+    fn slerp(_self: Val<bevy::math::Quat>, end: Val<bevy::math::Quat>, s: f32) {
+        let output: Val<bevy::math::Quat> = bevy::math::Quat::slerp(
+                _self.into_inner(),
+                end.into_inner(),
+                s,
+            )
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Quat>) {
+        let output: Val<bevy::math::Quat> = <bevy::math::Quat as std::ops::Sub<
+            bevy::math::Quat,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::Quat>) {
+        let output: [f32; 4] = bevy::math::Quat::to_array(&_self).into();
+        output
+    }
+    fn to_euler(_self: Val<bevy::math::Quat>, order: Val<bevy::math::EulerRot>) {
+        let output: (f32, f32, f32) = bevy::math::Quat::to_euler(
+                _self.into_inner(),
+                order.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn to_scaled_axis(_self: Val<bevy::math::Quat>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Quat::to_scaled_axis(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn xyz(_self: Val<bevy::math::Quat>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Quat::xyz(_self.into_inner())
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "vec_3")]
+impl bevy::math::Vec3 {
+    fn abs(_self: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::abs(_self.into_inner())
+            .into();
+        output
+    }
+    fn abs_diff_eq(
+        _self: Val<bevy::math::Vec3>,
+        rhs: Val<bevy::math::Vec3>,
+        max_abs_diff: f32,
+    ) {
+        let output: bool = bevy::math::Vec3::abs_diff_eq(
+                _self.into_inner(),
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::Vec3>, rhs: Ref<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Add<
+            &bevy::math::Vec3,
+        >>::add(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Add<
+            bevy::math::Vec3,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::Vec3>, rhs: f32) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Add<
+            f32,
+        >>::add(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn angle_between(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: f32 = bevy::math::Vec3::angle_between(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn any_orthogonal_vector(_self: Ref<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::any_orthogonal_vector(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn any_orthonormal_vector(_self: Ref<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::any_orthonormal_vector(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn as_dvec3(_self: Ref<bevy::math::Vec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::Vec3::as_dvec3(&_self).into();
+        output
+    }
+    fn as_i64vec3(_self: Ref<bevy::math::Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::Vec3::as_i64vec3(&_self)
+            .into();
+        output
+    }
+    fn as_ivec3(_self: Ref<bevy::math::Vec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::Vec3::as_ivec3(&_self).into();
+        output
+    }
+    fn as_u64vec3(_self: Ref<bevy::math::Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::Vec3::as_u64vec3(&_self)
+            .into();
+        output
+    }
+    fn as_uvec3(_self: Ref<bevy::math::Vec3>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::Vec3::as_uvec3(&_self).into();
+        output
+    }
+    fn ceil(_self: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::ceil(_self.into_inner())
+            .into();
+        output
+    }
+    fn clamp(
+        _self: Val<bevy::math::Vec3>,
+        min: Val<bevy::math::Vec3>,
+        max: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::clamp(
+                _self.into_inner(),
+                min.into_inner(),
+                max.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clamp_length(_self: Val<bevy::math::Vec3>, min: f32, max: f32) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::clamp_length(
+                _self.into_inner(),
+                min,
+                max,
+            )
+            .into();
+        output
+    }
+    fn clamp_length_max(_self: Val<bevy::math::Vec3>, max: f32) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::clamp_length_max(
+                _self.into_inner(),
+                max,
+            )
+            .into();
+        output
+    }
+    fn clamp_length_min(_self: Val<bevy::math::Vec3>, min: f32) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::clamp_length_min(
+                _self.into_inner(),
+                min,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn cmpeq(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::Vec3::cmpeq(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpge(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::Vec3::cmpge(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpgt(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::Vec3::cmpgt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmple(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::Vec3::cmple(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmplt(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::Vec3::cmplt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpne(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::Vec3::cmpne(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn copysign(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::copysign(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cross(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::cross(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: f32 = bevy::math::Vec3::distance(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance_squared(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: f32 = bevy::math::Vec3::distance_squared(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::Vec3>, rhs: Ref<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Div<
+            &bevy::math::Vec3,
+        >>::div(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Div<
+            bevy::math::Vec3,
+        >>::div(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::Vec3>, rhs: f32) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Div<
+            f32,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_euclid(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::div_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: f32 = bevy::math::Vec3::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn dot_into_vec(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::dot_into_vec(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn element_product(_self: Val<bevy::math::Vec3>) {
+        let output: f32 = bevy::math::Vec3::element_product(_self.into_inner()).into();
+        output
+    }
+    fn element_sum(_self: Val<bevy::math::Vec3>) {
+        let output: f32 = bevy::math::Vec3::element_sum(_self.into_inner()).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::Vec3>, other: Ref<bevy::math::Vec3>) {
+        let output: bool = <bevy::math::Vec3 as std::cmp::PartialEq<
+            bevy::math::Vec3,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn exp(_self: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::exp(_self.into_inner())
+            .into();
+        output
+    }
+    fn extend(_self: Val<bevy::math::Vec3>, w: f32) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec3::extend(
+                _self.into_inner(),
+                w,
+            )
+            .into();
+        output
+    }
+    fn floor(_self: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::floor(_self.into_inner())
+            .into();
+        output
+    }
+    fn fract(_self: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::fract(_self.into_inner())
+            .into();
+        output
+    }
+    fn fract_gl(_self: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::fract_gl(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_array(a: [f32; 3]) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::from_array(a).into();
+        output
+    }
+    fn is_finite(_self: Val<bevy::math::Vec3>) {
+        let output: bool = bevy::math::Vec3::is_finite(_self.into_inner()).into();
+        output
+    }
+    fn is_finite_mask(_self: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::Vec3::is_finite_mask(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn is_nan(_self: Val<bevy::math::Vec3>) {
+        let output: bool = bevy::math::Vec3::is_nan(_self.into_inner()).into();
+        output
+    }
+    fn is_nan_mask(_self: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::Vec3::is_nan_mask(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn is_negative_bitmask(_self: Val<bevy::math::Vec3>) {
+        let output: u32 = bevy::math::Vec3::is_negative_bitmask(_self.into_inner())
+            .into();
+        output
+    }
+    fn is_normalized(_self: Val<bevy::math::Vec3>) {
+        let output: bool = bevy::math::Vec3::is_normalized(_self.into_inner()).into();
+        output
+    }
+    fn length(_self: Val<bevy::math::Vec3>) {
+        let output: f32 = bevy::math::Vec3::length(_self.into_inner()).into();
+        output
+    }
+    fn length_recip(_self: Val<bevy::math::Vec3>) {
+        let output: f32 = bevy::math::Vec3::length_recip(_self.into_inner()).into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::Vec3>) {
+        let output: f32 = bevy::math::Vec3::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn lerp(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>, s: f32) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::lerp(
+                _self.into_inner(),
+                rhs.into_inner(),
+                s,
+            )
+            .into();
+        output
+    }
+    fn max(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::max(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn max_element(_self: Val<bevy::math::Vec3>) {
+        let output: f32 = bevy::math::Vec3::max_element(_self.into_inner()).into();
+        output
+    }
+    fn midpoint(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::midpoint(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::min(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min_element(_self: Val<bevy::math::Vec3>) {
+        let output: f32 = bevy::math::Vec3::min_element(_self.into_inner()).into();
+        output
+    }
+    fn move_towards(_self: Ref<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>, d: f32) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::move_towards(
+                &_self,
+                rhs.into_inner(),
+                d,
+            )
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Vec3>, rhs: Ref<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Mul<
+            &bevy::math::Vec3,
+        >>::mul(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Mul<
+            bevy::math::Vec3,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Vec3>, rhs: f32) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Mul<
+            f32,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn mul_add(
+        _self: Val<bevy::math::Vec3>,
+        a: Val<bevy::math::Vec3>,
+        b: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::mul_add(
+                _self.into_inner(),
+                a.into_inner(),
+                b.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(x: f32, y: f32, z: f32) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::new(x, y, z).into();
+        output
+    }
+    fn normalize(_self: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::normalize(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn normalize_or(_self: Val<bevy::math::Vec3>, fallback: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::normalize_or(
+                _self.into_inner(),
+                fallback.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn normalize_or_zero(_self: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::normalize_or_zero(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn powf(_self: Val<bevy::math::Vec3>, n: f32) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::powf(_self.into_inner(), n)
+            .into();
+        output
+    }
+    fn project_onto(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::project_onto(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn project_onto_normalized(
+        _self: Val<bevy::math::Vec3>,
+        rhs: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::project_onto_normalized(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn recip(_self: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::recip(_self.into_inner())
+            .into();
+        output
+    }
+    fn reflect(_self: Val<bevy::math::Vec3>, normal: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::reflect(
+                _self.into_inner(),
+                normal.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn refract(_self: Val<bevy::math::Vec3>, normal: Val<bevy::math::Vec3>, eta: f32) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::refract(
+                _self.into_inner(),
+                normal.into_inner(),
+                eta,
+            )
+            .into();
+        output
+    }
+    fn reject_from(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::reject_from(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn reject_from_normalized(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::reject_from_normalized(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::Vec3>, rhs: Ref<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Rem<
+            &bevy::math::Vec3,
+        >>::rem(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Rem<
+            bevy::math::Vec3,
+        >>::rem(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::Vec3>, rhs: f32) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Rem<
+            f32,
+        >>::rem(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn rem_euclid(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::rem_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn round(_self: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::round(_self.into_inner())
+            .into();
+        output
+    }
+    fn select(
+        mask: Val<bevy::math::BVec3>,
+        if_true: Val<bevy::math::Vec3>,
+        if_false: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::select(
+                mask.into_inner(),
+                if_true.into_inner(),
+                if_false.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn signum(_self: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::signum(_self.into_inner())
+            .into();
+        output
+    }
+    fn splat(v: f32) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::splat(v).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::Vec3>, rhs: Ref<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Sub<
+            &bevy::math::Vec3,
+        >>::sub(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Sub<
+            bevy::math::Vec3,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::Vec3>, rhs: f32) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Sub<
+            f32,
+        >>::sub(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::Vec3>) {
+        let output: [f32; 3] = bevy::math::Vec3::to_array(&_self).into();
+        output
+    }
+    fn trunc(_self: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::trunc(_self.into_inner())
+            .into();
+        output
+    }
+    fn truncate(_self: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec3::truncate(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn with_x(_self: Val<bevy::math::Vec3>, x: f32) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::with_x(
+                _self.into_inner(),
+                x,
+            )
+            .into();
+        output
+    }
+    fn with_y(_self: Val<bevy::math::Vec3>, y: f32) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::with_y(
+                _self.into_inner(),
+                y,
+            )
+            .into();
+        output
+    }
+    fn with_z(_self: Val<bevy::math::Vec3>, z: f32) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec3::with_z(
+                _self.into_inner(),
+                z,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "i_vec_2")]
+impl bevy::math::IVec2 {
+    fn abs(_self: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::abs(_self.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::IVec2>, rhs: Ref<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Add<
+            &bevy::math::IVec2,
+        >>::add(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Add<
+            bevy::math::IVec2,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::IVec2>, rhs: i32) {
+        let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Add<
+            i32,
+        >>::add(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn as_dvec2(_self: Ref<bevy::math::IVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::IVec2::as_dvec2(&_self).into();
+        output
+    }
+    fn as_i64vec2(_self: Ref<bevy::math::IVec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::IVec2::as_i64vec2(&_self)
+            .into();
+        output
+    }
+    fn as_u64vec2(_self: Ref<bevy::math::IVec2>) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::IVec2::as_u64vec2(&_self)
+            .into();
+        output
+    }
+    fn as_uvec2(_self: Ref<bevy::math::IVec2>) {
+        let output: Val<bevy::math::UVec2> = bevy::math::IVec2::as_uvec2(&_self).into();
+        output
+    }
+    fn as_vec2(_self: Ref<bevy::math::IVec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::IVec2::as_vec2(&_self).into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::IVec2>) {
+        let output: () = <bevy::math::IVec2 as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clamp(
+        _self: Val<bevy::math::IVec2>,
+        min: Val<bevy::math::IVec2>,
+        max: Val<bevy::math::IVec2>,
+    ) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::clamp(
+                _self.into_inner(),
+                min.into_inner(),
+                max.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn cmpeq(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::IVec2::cmpeq(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpge(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::IVec2::cmpge(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpgt(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::IVec2::cmpgt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmple(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::IVec2::cmple(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmplt(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::IVec2::cmplt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpne(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::IVec2::cmpne(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance_squared(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: i32 = bevy::math::IVec2::distance_squared(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::IVec2>, rhs: Ref<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Div<
+            &bevy::math::IVec2,
+        >>::div(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Div<
+            bevy::math::IVec2,
+        >>::div(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::IVec2>, rhs: i32) {
+        let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Div<
+            i32,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_euclid(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::div_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: i32 = bevy::math::IVec2::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn dot_into_vec(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::dot_into_vec(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn element_product(_self: Val<bevy::math::IVec2>) {
+        let output: i32 = bevy::math::IVec2::element_product(_self.into_inner()).into();
+        output
+    }
+    fn element_sum(_self: Val<bevy::math::IVec2>) {
+        let output: i32 = bevy::math::IVec2::element_sum(_self.into_inner()).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::IVec2>, other: Ref<bevy::math::IVec2>) {
+        let output: bool = <bevy::math::IVec2 as std::cmp::PartialEq<
+            bevy::math::IVec2,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn extend(_self: Val<bevy::math::IVec2>, z: i32) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec2::extend(
+                _self.into_inner(),
+                z,
+            )
+            .into();
+        output
+    }
+    fn from_array(a: [i32; 2]) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::from_array(a).into();
+        output
+    }
+    fn is_negative_bitmask(_self: Val<bevy::math::IVec2>) {
+        let output: u32 = bevy::math::IVec2::is_negative_bitmask(_self.into_inner())
+            .into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::IVec2>) {
+        let output: i32 = bevy::math::IVec2::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn max(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::max(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn max_element(_self: Val<bevy::math::IVec2>) {
+        let output: i32 = bevy::math::IVec2::max_element(_self.into_inner()).into();
+        output
+    }
+    fn min(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::min(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min_element(_self: Val<bevy::math::IVec2>) {
+        let output: i32 = bevy::math::IVec2::min_element(_self.into_inner()).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::IVec2>, rhs: Ref<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Mul<
+            &bevy::math::IVec2,
+        >>::mul(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Mul<
+            bevy::math::IVec2,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::IVec2>, rhs: i32) {
+        let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Mul<
+            i32,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(x: i32, y: i32) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::new(x, y).into();
+        output
+    }
+    fn perp(_self: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::perp(_self.into_inner())
+            .into();
+        output
+    }
+    fn perp_dot(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: i32 = bevy::math::IVec2::perp_dot(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::IVec2>, rhs: Ref<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Rem<
+            &bevy::math::IVec2,
+        >>::rem(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Rem<
+            bevy::math::IVec2,
+        >>::rem(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::IVec2>, rhs: i32) {
+        let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Rem<
+            i32,
+        >>::rem(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn rem_euclid(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::rem_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rotate(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::rotate(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_add(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::saturating_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_add_unsigned(
+        _self: Val<bevy::math::IVec2>,
+        rhs: Val<bevy::math::UVec2>,
+    ) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::saturating_add_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_div(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::saturating_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_mul(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::saturating_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_sub(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::saturating_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_sub_unsigned(
+        _self: Val<bevy::math::IVec2>,
+        rhs: Val<bevy::math::UVec2>,
+    ) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::saturating_sub_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn select(
+        mask: Val<bevy::math::BVec2>,
+        if_true: Val<bevy::math::IVec2>,
+        if_false: Val<bevy::math::IVec2>,
+    ) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::select(
+                mask.into_inner(),
+                if_true.into_inner(),
+                if_false.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn signum(_self: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::signum(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn splat(v: i32) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::splat(v).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::IVec2>, rhs: Ref<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Sub<
+            &bevy::math::IVec2,
+        >>::sub(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Sub<
+            bevy::math::IVec2,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::IVec2>, rhs: i32) {
+        let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Sub<
+            i32,
+        >>::sub(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::IVec2>) {
+        let output: [i32; 2] = bevy::math::IVec2::to_array(&_self).into();
+        output
+    }
+    fn with_x(_self: Val<bevy::math::IVec2>, x: i32) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::with_x(
+                _self.into_inner(),
+                x,
+            )
+            .into();
+        output
+    }
+    fn with_y(_self: Val<bevy::math::IVec2>, y: i32) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::with_y(
+                _self.into_inner(),
+                y,
+            )
+            .into();
+        output
+    }
+    fn wrapping_add(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::wrapping_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_add_unsigned(
+        _self: Val<bevy::math::IVec2>,
+        rhs: Val<bevy::math::UVec2>,
+    ) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::wrapping_add_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_div(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::wrapping_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_mul(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::wrapping_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_sub(_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::wrapping_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_sub_unsigned(
+        _self: Val<bevy::math::IVec2>,
+        rhs: Val<bevy::math::UVec2>,
+    ) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec2::wrapping_sub_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "i_vec_3")]
+impl bevy::math::IVec3 {
+    fn abs(_self: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::abs(_self.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::IVec3>, rhs: Ref<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Add<
+            &bevy::math::IVec3,
+        >>::add(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Add<
+            bevy::math::IVec3,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::IVec3>, rhs: i32) {
+        let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Add<
+            i32,
+        >>::add(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn as_dvec3(_self: Ref<bevy::math::IVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::IVec3::as_dvec3(&_self).into();
+        output
+    }
+    fn as_i64vec3(_self: Ref<bevy::math::IVec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::IVec3::as_i64vec3(&_self)
+            .into();
+        output
+    }
+    fn as_u64vec3(_self: Ref<bevy::math::IVec3>) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::IVec3::as_u64vec3(&_self)
+            .into();
+        output
+    }
+    fn as_uvec3(_self: Ref<bevy::math::IVec3>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::IVec3::as_uvec3(&_self).into();
+        output
+    }
+    fn as_vec3(_self: Ref<bevy::math::IVec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::IVec3::as_vec3(&_self).into();
+        output
+    }
+    fn as_vec3a(_self: Ref<bevy::math::IVec3>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::IVec3::as_vec3a(&_self).into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::IVec3>) {
+        let output: () = <bevy::math::IVec3 as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clamp(
+        _self: Val<bevy::math::IVec3>,
+        min: Val<bevy::math::IVec3>,
+        max: Val<bevy::math::IVec3>,
+    ) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::clamp(
+                _self.into_inner(),
+                min.into_inner(),
+                max.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn cmpeq(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::IVec3::cmpeq(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpge(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::IVec3::cmpge(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpgt(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::IVec3::cmpgt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmple(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::IVec3::cmple(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmplt(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::IVec3::cmplt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpne(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::IVec3::cmpne(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cross(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::cross(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance_squared(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: i32 = bevy::math::IVec3::distance_squared(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::IVec3>, rhs: Ref<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Div<
+            &bevy::math::IVec3,
+        >>::div(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Div<
+            bevy::math::IVec3,
+        >>::div(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::IVec3>, rhs: i32) {
+        let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Div<
+            i32,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_euclid(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::div_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: i32 = bevy::math::IVec3::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn dot_into_vec(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::dot_into_vec(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn element_product(_self: Val<bevy::math::IVec3>) {
+        let output: i32 = bevy::math::IVec3::element_product(_self.into_inner()).into();
+        output
+    }
+    fn element_sum(_self: Val<bevy::math::IVec3>) {
+        let output: i32 = bevy::math::IVec3::element_sum(_self.into_inner()).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::IVec3>, other: Ref<bevy::math::IVec3>) {
+        let output: bool = <bevy::math::IVec3 as std::cmp::PartialEq<
+            bevy::math::IVec3,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn extend(_self: Val<bevy::math::IVec3>, w: i32) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec3::extend(
+                _self.into_inner(),
+                w,
+            )
+            .into();
+        output
+    }
+    fn from_array(a: [i32; 3]) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::from_array(a).into();
+        output
+    }
+    fn is_negative_bitmask(_self: Val<bevy::math::IVec3>) {
+        let output: u32 = bevy::math::IVec3::is_negative_bitmask(_self.into_inner())
+            .into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::IVec3>) {
+        let output: i32 = bevy::math::IVec3::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn max(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::max(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn max_element(_self: Val<bevy::math::IVec3>) {
+        let output: i32 = bevy::math::IVec3::max_element(_self.into_inner()).into();
+        output
+    }
+    fn min(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::min(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min_element(_self: Val<bevy::math::IVec3>) {
+        let output: i32 = bevy::math::IVec3::min_element(_self.into_inner()).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::IVec3>, rhs: Ref<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Mul<
+            &bevy::math::IVec3,
+        >>::mul(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Mul<
+            bevy::math::IVec3,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::IVec3>, rhs: i32) {
+        let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Mul<
+            i32,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(x: i32, y: i32, z: i32) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::new(x, y, z).into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::IVec3>, rhs: Ref<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Rem<
+            &bevy::math::IVec3,
+        >>::rem(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Rem<
+            bevy::math::IVec3,
+        >>::rem(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::IVec3>, rhs: i32) {
+        let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Rem<
+            i32,
+        >>::rem(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn rem_euclid(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::rem_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_add(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::saturating_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_add_unsigned(
+        _self: Val<bevy::math::IVec3>,
+        rhs: Val<bevy::math::UVec3>,
+    ) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::saturating_add_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_div(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::saturating_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_mul(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::saturating_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_sub(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::saturating_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_sub_unsigned(
+        _self: Val<bevy::math::IVec3>,
+        rhs: Val<bevy::math::UVec3>,
+    ) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::saturating_sub_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn select(
+        mask: Val<bevy::math::BVec3>,
+        if_true: Val<bevy::math::IVec3>,
+        if_false: Val<bevy::math::IVec3>,
+    ) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::select(
+                mask.into_inner(),
+                if_true.into_inner(),
+                if_false.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn signum(_self: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::signum(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn splat(v: i32) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::splat(v).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::IVec3>, rhs: Ref<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Sub<
+            &bevy::math::IVec3,
+        >>::sub(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Sub<
+            bevy::math::IVec3,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::IVec3>, rhs: i32) {
+        let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Sub<
+            i32,
+        >>::sub(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::IVec3>) {
+        let output: [i32; 3] = bevy::math::IVec3::to_array(&_self).into();
+        output
+    }
+    fn truncate(_self: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::IVec3::truncate(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn with_x(_self: Val<bevy::math::IVec3>, x: i32) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::with_x(
+                _self.into_inner(),
+                x,
+            )
+            .into();
+        output
+    }
+    fn with_y(_self: Val<bevy::math::IVec3>, y: i32) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::with_y(
+                _self.into_inner(),
+                y,
+            )
+            .into();
+        output
+    }
+    fn with_z(_self: Val<bevy::math::IVec3>, z: i32) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::with_z(
+                _self.into_inner(),
+                z,
+            )
+            .into();
+        output
+    }
+    fn wrapping_add(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::wrapping_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_add_unsigned(
+        _self: Val<bevy::math::IVec3>,
+        rhs: Val<bevy::math::UVec3>,
+    ) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::wrapping_add_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_div(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::wrapping_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_mul(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::wrapping_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_sub(_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::wrapping_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_sub_unsigned(
+        _self: Val<bevy::math::IVec3>,
+        rhs: Val<bevy::math::UVec3>,
+    ) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec3::wrapping_sub_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "i_vec_4")]
+impl bevy::math::IVec4 {
+    fn abs(_self: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::abs(_self.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::IVec4>, rhs: Ref<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Add<
+            &bevy::math::IVec4,
+        >>::add(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Add<
+            bevy::math::IVec4,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::IVec4>, rhs: i32) {
+        let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Add<
+            i32,
+        >>::add(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn as_dvec4(_self: Ref<bevy::math::IVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::IVec4::as_dvec4(&_self).into();
+        output
+    }
+    fn as_i64vec4(_self: Ref<bevy::math::IVec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::IVec4::as_i64vec4(&_self)
+            .into();
+        output
+    }
+    fn as_u64vec4(_self: Ref<bevy::math::IVec4>) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::IVec4::as_u64vec4(&_self)
+            .into();
+        output
+    }
+    fn as_uvec4(_self: Ref<bevy::math::IVec4>) {
+        let output: Val<bevy::math::UVec4> = bevy::math::IVec4::as_uvec4(&_self).into();
+        output
+    }
+    fn as_vec4(_self: Ref<bevy::math::IVec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::IVec4::as_vec4(&_self).into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::IVec4>) {
+        let output: () = <bevy::math::IVec4 as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clamp(
+        _self: Val<bevy::math::IVec4>,
+        min: Val<bevy::math::IVec4>,
+        max: Val<bevy::math::IVec4>,
+    ) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::clamp(
+                _self.into_inner(),
+                min.into_inner(),
+                max.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn cmpeq(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::IVec4::cmpeq(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpge(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::IVec4::cmpge(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpgt(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::IVec4::cmpgt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmple(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::IVec4::cmple(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmplt(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::IVec4::cmplt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpne(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::IVec4::cmpne(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance_squared(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: i32 = bevy::math::IVec4::distance_squared(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::IVec4>, rhs: Ref<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Div<
+            &bevy::math::IVec4,
+        >>::div(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Div<
+            bevy::math::IVec4,
+        >>::div(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::IVec4>, rhs: i32) {
+        let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Div<
+            i32,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_euclid(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::div_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: i32 = bevy::math::IVec4::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn dot_into_vec(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::dot_into_vec(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn element_product(_self: Val<bevy::math::IVec4>) {
+        let output: i32 = bevy::math::IVec4::element_product(_self.into_inner()).into();
+        output
+    }
+    fn element_sum(_self: Val<bevy::math::IVec4>) {
+        let output: i32 = bevy::math::IVec4::element_sum(_self.into_inner()).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::IVec4>, other: Ref<bevy::math::IVec4>) {
+        let output: bool = <bevy::math::IVec4 as std::cmp::PartialEq<
+            bevy::math::IVec4,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_array(a: [i32; 4]) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::from_array(a).into();
+        output
+    }
+    fn is_negative_bitmask(_self: Val<bevy::math::IVec4>) {
+        let output: u32 = bevy::math::IVec4::is_negative_bitmask(_self.into_inner())
+            .into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::IVec4>) {
+        let output: i32 = bevy::math::IVec4::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn max(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::max(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn max_element(_self: Val<bevy::math::IVec4>) {
+        let output: i32 = bevy::math::IVec4::max_element(_self.into_inner()).into();
+        output
+    }
+    fn min(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::min(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min_element(_self: Val<bevy::math::IVec4>) {
+        let output: i32 = bevy::math::IVec4::min_element(_self.into_inner()).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::IVec4>, rhs: Ref<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Mul<
+            &bevy::math::IVec4,
+        >>::mul(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Mul<
+            bevy::math::IVec4,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::IVec4>, rhs: i32) {
+        let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Mul<
+            i32,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(x: i32, y: i32, z: i32, w: i32) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::new(x, y, z, w).into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::IVec4>, rhs: Ref<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Rem<
+            &bevy::math::IVec4,
+        >>::rem(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Rem<
+            bevy::math::IVec4,
+        >>::rem(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::IVec4>, rhs: i32) {
+        let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Rem<
+            i32,
+        >>::rem(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn rem_euclid(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::rem_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_add(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::saturating_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_add_unsigned(
+        _self: Val<bevy::math::IVec4>,
+        rhs: Val<bevy::math::UVec4>,
+    ) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::saturating_add_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_div(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::saturating_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_mul(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::saturating_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_sub(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::saturating_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_sub_unsigned(
+        _self: Val<bevy::math::IVec4>,
+        rhs: Val<bevy::math::UVec4>,
+    ) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::saturating_sub_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn select(
+        mask: Val<bevy::math::BVec4>,
+        if_true: Val<bevy::math::IVec4>,
+        if_false: Val<bevy::math::IVec4>,
+    ) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::select(
+                mask.into_inner(),
+                if_true.into_inner(),
+                if_false.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn signum(_self: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::signum(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn splat(v: i32) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::splat(v).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::IVec4>, rhs: Ref<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Sub<
+            &bevy::math::IVec4,
+        >>::sub(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Sub<
+            bevy::math::IVec4,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::IVec4>, rhs: i32) {
+        let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Sub<
+            i32,
+        >>::sub(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::IVec4>) {
+        let output: [i32; 4] = bevy::math::IVec4::to_array(&_self).into();
+        output
+    }
+    fn truncate(_self: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::IVec4::truncate(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn with_w(_self: Val<bevy::math::IVec4>, w: i32) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::with_w(
+                _self.into_inner(),
+                w,
+            )
+            .into();
+        output
+    }
+    fn with_x(_self: Val<bevy::math::IVec4>, x: i32) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::with_x(
+                _self.into_inner(),
+                x,
+            )
+            .into();
+        output
+    }
+    fn with_y(_self: Val<bevy::math::IVec4>, y: i32) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::with_y(
+                _self.into_inner(),
+                y,
+            )
+            .into();
+        output
+    }
+    fn with_z(_self: Val<bevy::math::IVec4>, z: i32) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::with_z(
+                _self.into_inner(),
+                z,
+            )
+            .into();
+        output
+    }
+    fn wrapping_add(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::wrapping_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_add_unsigned(
+        _self: Val<bevy::math::IVec4>,
+        rhs: Val<bevy::math::UVec4>,
+    ) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::wrapping_add_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_div(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::wrapping_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_mul(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::wrapping_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_sub(_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::wrapping_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_sub_unsigned(
+        _self: Val<bevy::math::IVec4>,
+        rhs: Val<bevy::math::UVec4>,
+    ) {
+        let output: Val<bevy::math::IVec4> = bevy::math::IVec4::wrapping_sub_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "i_64_vec_2")]
+impl bevy::math::I64Vec2 {
+    fn abs(_self: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::abs(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::I64Vec2>, rhs: Ref<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Add<
+            &bevy::math::I64Vec2,
+        >>::add(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Add<
+            bevy::math::I64Vec2,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::I64Vec2>, rhs: i64) {
+        let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Add<
+            i64,
+        >>::add(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn as_dvec2(_self: Ref<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::I64Vec2::as_dvec2(&_self)
+            .into();
+        output
+    }
+    fn as_ivec2(_self: Ref<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::I64Vec2::as_ivec2(&_self)
+            .into();
+        output
+    }
+    fn as_u64vec2(_self: Ref<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::I64Vec2::as_u64vec2(&_self)
+            .into();
+        output
+    }
+    fn as_uvec2(_self: Ref<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::UVec2> = bevy::math::I64Vec2::as_uvec2(&_self)
+            .into();
+        output
+    }
+    fn as_vec2(_self: Ref<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::I64Vec2::as_vec2(&_self).into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::I64Vec2>) {
+        let output: () = <bevy::math::I64Vec2 as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clamp(
+        _self: Val<bevy::math::I64Vec2>,
+        min: Val<bevy::math::I64Vec2>,
+        max: Val<bevy::math::I64Vec2>,
+    ) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::clamp(
+                _self.into_inner(),
+                min.into_inner(),
+                max.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn cmpeq(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::I64Vec2::cmpeq(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpge(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::I64Vec2::cmpge(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpgt(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::I64Vec2::cmpgt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmple(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::I64Vec2::cmple(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmplt(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::I64Vec2::cmplt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpne(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::I64Vec2::cmpne(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance_squared(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: i64 = bevy::math::I64Vec2::distance_squared(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::I64Vec2>, rhs: Ref<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Div<
+            &bevy::math::I64Vec2,
+        >>::div(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Div<
+            bevy::math::I64Vec2,
+        >>::div(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::I64Vec2>, rhs: i64) {
+        let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Div<
+            i64,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_euclid(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::div_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: i64 = bevy::math::I64Vec2::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn dot_into_vec(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::dot_into_vec(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn element_product(_self: Val<bevy::math::I64Vec2>) {
+        let output: i64 = bevy::math::I64Vec2::element_product(_self.into_inner())
+            .into();
+        output
+    }
+    fn element_sum(_self: Val<bevy::math::I64Vec2>) {
+        let output: i64 = bevy::math::I64Vec2::element_sum(_self.into_inner()).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::I64Vec2>, other: Ref<bevy::math::I64Vec2>) {
+        let output: bool = <bevy::math::I64Vec2 as std::cmp::PartialEq<
+            bevy::math::I64Vec2,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn extend(_self: Val<bevy::math::I64Vec2>, z: i64) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec2::extend(
+                _self.into_inner(),
+                z,
+            )
+            .into();
+        output
+    }
+    fn from_array(a: [i64; 2]) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::from_array(a).into();
+        output
+    }
+    fn is_negative_bitmask(_self: Val<bevy::math::I64Vec2>) {
+        let output: u32 = bevy::math::I64Vec2::is_negative_bitmask(_self.into_inner())
+            .into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::I64Vec2>) {
+        let output: i64 = bevy::math::I64Vec2::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn max(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::max(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn max_element(_self: Val<bevy::math::I64Vec2>) {
+        let output: i64 = bevy::math::I64Vec2::max_element(_self.into_inner()).into();
+        output
+    }
+    fn min(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::min(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min_element(_self: Val<bevy::math::I64Vec2>) {
+        let output: i64 = bevy::math::I64Vec2::min_element(_self.into_inner()).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::I64Vec2>, rhs: Ref<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Mul<
+            &bevy::math::I64Vec2,
+        >>::mul(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Mul<
+            bevy::math::I64Vec2,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::I64Vec2>, rhs: i64) {
+        let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Mul<
+            i64,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(x: i64, y: i64) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::new(x, y).into();
+        output
+    }
+    fn perp(_self: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::perp(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn perp_dot(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: i64 = bevy::math::I64Vec2::perp_dot(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::I64Vec2>, rhs: Ref<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Rem<
+            &bevy::math::I64Vec2,
+        >>::rem(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Rem<
+            bevy::math::I64Vec2,
+        >>::rem(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::I64Vec2>, rhs: i64) {
+        let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Rem<
+            i64,
+        >>::rem(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn rem_euclid(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::rem_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rotate(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::rotate(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_add(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::saturating_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_add_unsigned(
+        _self: Val<bevy::math::I64Vec2>,
+        rhs: Val<bevy::math::U64Vec2>,
+    ) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::saturating_add_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_div(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::saturating_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_mul(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::saturating_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_sub(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::saturating_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_sub_unsigned(
+        _self: Val<bevy::math::I64Vec2>,
+        rhs: Val<bevy::math::U64Vec2>,
+    ) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::saturating_sub_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn select(
+        mask: Val<bevy::math::BVec2>,
+        if_true: Val<bevy::math::I64Vec2>,
+        if_false: Val<bevy::math::I64Vec2>,
+    ) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::select(
+                mask.into_inner(),
+                if_true.into_inner(),
+                if_false.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn signum(_self: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::signum(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn splat(v: i64) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::splat(v).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::I64Vec2>, rhs: Ref<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Sub<
+            &bevy::math::I64Vec2,
+        >>::sub(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Sub<
+            bevy::math::I64Vec2,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::I64Vec2>, rhs: i64) {
+        let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Sub<
+            i64,
+        >>::sub(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::I64Vec2>) {
+        let output: [i64; 2] = bevy::math::I64Vec2::to_array(&_self).into();
+        output
+    }
+    fn with_x(_self: Val<bevy::math::I64Vec2>, x: i64) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::with_x(
+                _self.into_inner(),
+                x,
+            )
+            .into();
+        output
+    }
+    fn with_y(_self: Val<bevy::math::I64Vec2>, y: i64) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::with_y(
+                _self.into_inner(),
+                y,
+            )
+            .into();
+        output
+    }
+    fn wrapping_add(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::wrapping_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_add_unsigned(
+        _self: Val<bevy::math::I64Vec2>,
+        rhs: Val<bevy::math::U64Vec2>,
+    ) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::wrapping_add_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_div(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::wrapping_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_mul(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::wrapping_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_sub(_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::wrapping_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_sub_unsigned(
+        _self: Val<bevy::math::I64Vec2>,
+        rhs: Val<bevy::math::U64Vec2>,
+    ) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::wrapping_sub_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "i_64_vec_3")]
+impl bevy::math::I64Vec3 {
+    fn abs(_self: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::abs(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::I64Vec3>, rhs: Ref<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Add<
+            &bevy::math::I64Vec3,
+        >>::add(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Add<
+            bevy::math::I64Vec3,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::I64Vec3>, rhs: i64) {
+        let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Add<
+            i64,
+        >>::add(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn as_dvec3(_self: Ref<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::I64Vec3::as_dvec3(&_self)
+            .into();
+        output
+    }
+    fn as_ivec3(_self: Ref<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::I64Vec3::as_ivec3(&_self)
+            .into();
+        output
+    }
+    fn as_u64vec3(_self: Ref<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::I64Vec3::as_u64vec3(&_self)
+            .into();
+        output
+    }
+    fn as_uvec3(_self: Ref<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::I64Vec3::as_uvec3(&_self)
+            .into();
+        output
+    }
+    fn as_vec3(_self: Ref<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::I64Vec3::as_vec3(&_self).into();
+        output
+    }
+    fn as_vec3a(_self: Ref<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::I64Vec3::as_vec3a(&_self)
+            .into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::I64Vec3>) {
+        let output: () = <bevy::math::I64Vec3 as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clamp(
+        _self: Val<bevy::math::I64Vec3>,
+        min: Val<bevy::math::I64Vec3>,
+        max: Val<bevy::math::I64Vec3>,
+    ) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::clamp(
+                _self.into_inner(),
+                min.into_inner(),
+                max.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn cmpeq(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::I64Vec3::cmpeq(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpge(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::I64Vec3::cmpge(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpgt(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::I64Vec3::cmpgt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmple(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::I64Vec3::cmple(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmplt(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::I64Vec3::cmplt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpne(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::I64Vec3::cmpne(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cross(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::cross(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance_squared(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: i64 = bevy::math::I64Vec3::distance_squared(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::I64Vec3>, rhs: Ref<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Div<
+            &bevy::math::I64Vec3,
+        >>::div(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Div<
+            bevy::math::I64Vec3,
+        >>::div(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::I64Vec3>, rhs: i64) {
+        let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Div<
+            i64,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_euclid(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::div_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: i64 = bevy::math::I64Vec3::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn dot_into_vec(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::dot_into_vec(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn element_product(_self: Val<bevy::math::I64Vec3>) {
+        let output: i64 = bevy::math::I64Vec3::element_product(_self.into_inner())
+            .into();
+        output
+    }
+    fn element_sum(_self: Val<bevy::math::I64Vec3>) {
+        let output: i64 = bevy::math::I64Vec3::element_sum(_self.into_inner()).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::I64Vec3>, other: Ref<bevy::math::I64Vec3>) {
+        let output: bool = <bevy::math::I64Vec3 as std::cmp::PartialEq<
+            bevy::math::I64Vec3,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn extend(_self: Val<bevy::math::I64Vec3>, w: i64) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec3::extend(
+                _self.into_inner(),
+                w,
+            )
+            .into();
+        output
+    }
+    fn from_array(a: [i64; 3]) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::from_array(a).into();
+        output
+    }
+    fn is_negative_bitmask(_self: Val<bevy::math::I64Vec3>) {
+        let output: u32 = bevy::math::I64Vec3::is_negative_bitmask(_self.into_inner())
+            .into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::I64Vec3>) {
+        let output: i64 = bevy::math::I64Vec3::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn max(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::max(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn max_element(_self: Val<bevy::math::I64Vec3>) {
+        let output: i64 = bevy::math::I64Vec3::max_element(_self.into_inner()).into();
+        output
+    }
+    fn min(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::min(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min_element(_self: Val<bevy::math::I64Vec3>) {
+        let output: i64 = bevy::math::I64Vec3::min_element(_self.into_inner()).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::I64Vec3>, rhs: Ref<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Mul<
+            &bevy::math::I64Vec3,
+        >>::mul(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Mul<
+            bevy::math::I64Vec3,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::I64Vec3>, rhs: i64) {
+        let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Mul<
+            i64,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(x: i64, y: i64, z: i64) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::new(x, y, z).into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::I64Vec3>, rhs: Ref<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Rem<
+            &bevy::math::I64Vec3,
+        >>::rem(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Rem<
+            bevy::math::I64Vec3,
+        >>::rem(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::I64Vec3>, rhs: i64) {
+        let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Rem<
+            i64,
+        >>::rem(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn rem_euclid(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::rem_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_add(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::saturating_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_add_unsigned(
+        _self: Val<bevy::math::I64Vec3>,
+        rhs: Val<bevy::math::U64Vec3>,
+    ) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::saturating_add_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_div(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::saturating_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_mul(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::saturating_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_sub(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::saturating_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_sub_unsigned(
+        _self: Val<bevy::math::I64Vec3>,
+        rhs: Val<bevy::math::U64Vec3>,
+    ) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::saturating_sub_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn select(
+        mask: Val<bevy::math::BVec3>,
+        if_true: Val<bevy::math::I64Vec3>,
+        if_false: Val<bevy::math::I64Vec3>,
+    ) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::select(
+                mask.into_inner(),
+                if_true.into_inner(),
+                if_false.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn signum(_self: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::signum(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn splat(v: i64) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::splat(v).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::I64Vec3>, rhs: Ref<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Sub<
+            &bevy::math::I64Vec3,
+        >>::sub(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Sub<
+            bevy::math::I64Vec3,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::I64Vec3>, rhs: i64) {
+        let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Sub<
+            i64,
+        >>::sub(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::I64Vec3>) {
+        let output: [i64; 3] = bevy::math::I64Vec3::to_array(&_self).into();
+        output
+    }
+    fn truncate(_self: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec3::truncate(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn with_x(_self: Val<bevy::math::I64Vec3>, x: i64) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::with_x(
+                _self.into_inner(),
+                x,
+            )
+            .into();
+        output
+    }
+    fn with_y(_self: Val<bevy::math::I64Vec3>, y: i64) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::with_y(
+                _self.into_inner(),
+                y,
+            )
+            .into();
+        output
+    }
+    fn with_z(_self: Val<bevy::math::I64Vec3>, z: i64) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::with_z(
+                _self.into_inner(),
+                z,
+            )
+            .into();
+        output
+    }
+    fn wrapping_add(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::wrapping_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_add_unsigned(
+        _self: Val<bevy::math::I64Vec3>,
+        rhs: Val<bevy::math::U64Vec3>,
+    ) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::wrapping_add_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_div(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::wrapping_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_mul(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::wrapping_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_sub(_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::wrapping_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_sub_unsigned(
+        _self: Val<bevy::math::I64Vec3>,
+        rhs: Val<bevy::math::U64Vec3>,
+    ) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::wrapping_sub_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "i_64_vec_4")]
+impl bevy::math::I64Vec4 {
+    fn abs(_self: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::abs(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::I64Vec4>, rhs: Ref<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Add<
+            &bevy::math::I64Vec4,
+        >>::add(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Add<
+            bevy::math::I64Vec4,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::I64Vec4>, rhs: i64) {
+        let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Add<
+            i64,
+        >>::add(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn as_dvec4(_self: Ref<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::I64Vec4::as_dvec4(&_self)
+            .into();
+        output
+    }
+    fn as_ivec4(_self: Ref<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::I64Vec4::as_ivec4(&_self)
+            .into();
+        output
+    }
+    fn as_u64vec4(_self: Ref<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::I64Vec4::as_u64vec4(&_self)
+            .into();
+        output
+    }
+    fn as_uvec4(_self: Ref<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::UVec4> = bevy::math::I64Vec4::as_uvec4(&_self)
+            .into();
+        output
+    }
+    fn as_vec4(_self: Ref<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::I64Vec4::as_vec4(&_self).into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::I64Vec4>) {
+        let output: () = <bevy::math::I64Vec4 as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clamp(
+        _self: Val<bevy::math::I64Vec4>,
+        min: Val<bevy::math::I64Vec4>,
+        max: Val<bevy::math::I64Vec4>,
+    ) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::clamp(
+                _self.into_inner(),
+                min.into_inner(),
+                max.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn cmpeq(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::I64Vec4::cmpeq(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpge(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::I64Vec4::cmpge(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpgt(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::I64Vec4::cmpgt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmple(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::I64Vec4::cmple(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmplt(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::I64Vec4::cmplt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpne(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::I64Vec4::cmpne(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance_squared(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: i64 = bevy::math::I64Vec4::distance_squared(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::I64Vec4>, rhs: Ref<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Div<
+            &bevy::math::I64Vec4,
+        >>::div(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Div<
+            bevy::math::I64Vec4,
+        >>::div(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::I64Vec4>, rhs: i64) {
+        let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Div<
+            i64,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_euclid(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::div_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: i64 = bevy::math::I64Vec4::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn dot_into_vec(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::dot_into_vec(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn element_product(_self: Val<bevy::math::I64Vec4>) {
+        let output: i64 = bevy::math::I64Vec4::element_product(_self.into_inner())
+            .into();
+        output
+    }
+    fn element_sum(_self: Val<bevy::math::I64Vec4>) {
+        let output: i64 = bevy::math::I64Vec4::element_sum(_self.into_inner()).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::I64Vec4>, other: Ref<bevy::math::I64Vec4>) {
+        let output: bool = <bevy::math::I64Vec4 as std::cmp::PartialEq<
+            bevy::math::I64Vec4,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_array(a: [i64; 4]) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::from_array(a).into();
+        output
+    }
+    fn is_negative_bitmask(_self: Val<bevy::math::I64Vec4>) {
+        let output: u32 = bevy::math::I64Vec4::is_negative_bitmask(_self.into_inner())
+            .into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::I64Vec4>) {
+        let output: i64 = bevy::math::I64Vec4::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn max(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::max(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn max_element(_self: Val<bevy::math::I64Vec4>) {
+        let output: i64 = bevy::math::I64Vec4::max_element(_self.into_inner()).into();
+        output
+    }
+    fn min(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::min(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min_element(_self: Val<bevy::math::I64Vec4>) {
+        let output: i64 = bevy::math::I64Vec4::min_element(_self.into_inner()).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::I64Vec4>, rhs: Ref<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Mul<
+            &bevy::math::I64Vec4,
+        >>::mul(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Mul<
+            bevy::math::I64Vec4,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::I64Vec4>, rhs: i64) {
+        let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Mul<
+            i64,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(x: i64, y: i64, z: i64, w: i64) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::new(x, y, z, w)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::I64Vec4>, rhs: Ref<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Rem<
+            &bevy::math::I64Vec4,
+        >>::rem(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Rem<
+            bevy::math::I64Vec4,
+        >>::rem(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::I64Vec4>, rhs: i64) {
+        let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Rem<
+            i64,
+        >>::rem(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn rem_euclid(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::rem_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_add(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::saturating_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_add_unsigned(
+        _self: Val<bevy::math::I64Vec4>,
+        rhs: Val<bevy::math::U64Vec4>,
+    ) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::saturating_add_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_div(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::saturating_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_mul(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::saturating_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_sub(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::saturating_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_sub_unsigned(
+        _self: Val<bevy::math::I64Vec4>,
+        rhs: Val<bevy::math::U64Vec4>,
+    ) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::saturating_sub_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn select(
+        mask: Val<bevy::math::BVec4>,
+        if_true: Val<bevy::math::I64Vec4>,
+        if_false: Val<bevy::math::I64Vec4>,
+    ) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::select(
+                mask.into_inner(),
+                if_true.into_inner(),
+                if_false.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn signum(_self: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::signum(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn splat(v: i64) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::splat(v).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::I64Vec4>, rhs: Ref<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Sub<
+            &bevy::math::I64Vec4,
+        >>::sub(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Sub<
+            bevy::math::I64Vec4,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::I64Vec4>, rhs: i64) {
+        let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Sub<
+            i64,
+        >>::sub(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::I64Vec4>) {
+        let output: [i64; 4] = bevy::math::I64Vec4::to_array(&_self).into();
+        output
+    }
+    fn truncate(_self: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec4::truncate(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn with_w(_self: Val<bevy::math::I64Vec4>, w: i64) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::with_w(
+                _self.into_inner(),
+                w,
+            )
+            .into();
+        output
+    }
+    fn with_x(_self: Val<bevy::math::I64Vec4>, x: i64) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::with_x(
+                _self.into_inner(),
+                x,
+            )
+            .into();
+        output
+    }
+    fn with_y(_self: Val<bevy::math::I64Vec4>, y: i64) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::with_y(
+                _self.into_inner(),
+                y,
+            )
+            .into();
+        output
+    }
+    fn with_z(_self: Val<bevy::math::I64Vec4>, z: i64) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::with_z(
+                _self.into_inner(),
+                z,
+            )
+            .into();
+        output
+    }
+    fn wrapping_add(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::wrapping_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_add_unsigned(
+        _self: Val<bevy::math::I64Vec4>,
+        rhs: Val<bevy::math::U64Vec4>,
+    ) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::wrapping_add_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_div(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::wrapping_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_mul(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::wrapping_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_sub(_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::wrapping_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_sub_unsigned(
+        _self: Val<bevy::math::I64Vec4>,
+        rhs: Val<bevy::math::U64Vec4>,
+    ) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::wrapping_sub_unsigned(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "u_vec_2")]
+impl bevy::math::UVec2 {
+    fn add(_self: Val<bevy::math::UVec2>, rhs: Ref<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Add<
+            &bevy::math::UVec2,
+        >>::add(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Add<
+            bevy::math::UVec2,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::UVec2>, rhs: u32) {
+        let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Add<
+            u32,
+        >>::add(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn as_dvec2(_self: Ref<bevy::math::UVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::UVec2::as_dvec2(&_self).into();
+        output
+    }
+    fn as_i64vec2(_self: Ref<bevy::math::UVec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::UVec2::as_i64vec2(&_self)
+            .into();
+        output
+    }
+    fn as_ivec2(_self: Ref<bevy::math::UVec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::UVec2::as_ivec2(&_self).into();
+        output
+    }
+    fn as_u64vec2(_self: Ref<bevy::math::UVec2>) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::UVec2::as_u64vec2(&_self)
+            .into();
+        output
+    }
+    fn as_vec2(_self: Ref<bevy::math::UVec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::UVec2::as_vec2(&_self).into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::UVec2>) {
+        let output: () = <bevy::math::UVec2 as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clamp(
+        _self: Val<bevy::math::UVec2>,
+        min: Val<bevy::math::UVec2>,
+        max: Val<bevy::math::UVec2>,
+    ) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::clamp(
+                _self.into_inner(),
+                min.into_inner(),
+                max.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn cmpeq(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::UVec2::cmpeq(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpge(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::UVec2::cmpge(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpgt(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::UVec2::cmpgt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmple(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::UVec2::cmple(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmplt(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::UVec2::cmplt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpne(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::UVec2::cmpne(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::UVec2>, rhs: Ref<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Div<
+            &bevy::math::UVec2,
+        >>::div(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Div<
+            bevy::math::UVec2,
+        >>::div(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::UVec2>, rhs: u32) {
+        let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Div<
+            u32,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: u32 = bevy::math::UVec2::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn dot_into_vec(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::dot_into_vec(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn element_product(_self: Val<bevy::math::UVec2>) {
+        let output: u32 = bevy::math::UVec2::element_product(_self.into_inner()).into();
+        output
+    }
+    fn element_sum(_self: Val<bevy::math::UVec2>) {
+        let output: u32 = bevy::math::UVec2::element_sum(_self.into_inner()).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::UVec2>, other: Ref<bevy::math::UVec2>) {
+        let output: bool = <bevy::math::UVec2 as std::cmp::PartialEq<
+            bevy::math::UVec2,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn extend(_self: Val<bevy::math::UVec2>, z: u32) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec2::extend(
+                _self.into_inner(),
+                z,
+            )
+            .into();
+        output
+    }
+    fn from_array(a: [u32; 2]) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::from_array(a).into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::UVec2>) {
+        let output: u32 = bevy::math::UVec2::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn max(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::max(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn max_element(_self: Val<bevy::math::UVec2>) {
+        let output: u32 = bevy::math::UVec2::max_element(_self.into_inner()).into();
+        output
+    }
+    fn min(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::min(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min_element(_self: Val<bevy::math::UVec2>) {
+        let output: u32 = bevy::math::UVec2::min_element(_self.into_inner()).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::UVec2>, rhs: Ref<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Mul<
+            &bevy::math::UVec2,
+        >>::mul(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Mul<
+            bevy::math::UVec2,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::UVec2>, rhs: u32) {
+        let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Mul<
+            u32,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn new(x: u32, y: u32) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::new(x, y).into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::UVec2>, rhs: Ref<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Rem<
+            &bevy::math::UVec2,
+        >>::rem(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Rem<
+            bevy::math::UVec2,
+        >>::rem(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::UVec2>, rhs: u32) {
+        let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Rem<
+            u32,
+        >>::rem(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn saturating_add(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::saturating_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_add_signed(
+        _self: Val<bevy::math::UVec2>,
+        rhs: Val<bevy::math::IVec2>,
+    ) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::saturating_add_signed(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_div(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::saturating_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_mul(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::saturating_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_sub(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::saturating_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn select(
+        mask: Val<bevy::math::BVec2>,
+        if_true: Val<bevy::math::UVec2>,
+        if_false: Val<bevy::math::UVec2>,
+    ) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::select(
+                mask.into_inner(),
+                if_true.into_inner(),
+                if_false.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn splat(v: u32) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::splat(v).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::UVec2>, rhs: Ref<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Sub<
+            &bevy::math::UVec2,
+        >>::sub(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Sub<
+            bevy::math::UVec2,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::UVec2>, rhs: u32) {
+        let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Sub<
+            u32,
+        >>::sub(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::UVec2>) {
+        let output: [u32; 2] = bevy::math::UVec2::to_array(&_self).into();
+        output
+    }
+    fn with_x(_self: Val<bevy::math::UVec2>, x: u32) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::with_x(
+                _self.into_inner(),
+                x,
+            )
+            .into();
+        output
+    }
+    fn with_y(_self: Val<bevy::math::UVec2>, y: u32) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::with_y(
+                _self.into_inner(),
+                y,
+            )
+            .into();
+        output
+    }
+    fn wrapping_add(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::wrapping_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_add_signed(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::IVec2>) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::wrapping_add_signed(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_div(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::wrapping_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_mul(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::wrapping_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_sub(_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec2::wrapping_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "u_vec_3")]
+impl bevy::math::UVec3 {
+    fn add(_self: Val<bevy::math::UVec3>, rhs: Ref<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Add<
+            &bevy::math::UVec3,
+        >>::add(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Add<
+            bevy::math::UVec3,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::UVec3>, rhs: u32) {
+        let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Add<
+            u32,
+        >>::add(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn as_dvec3(_self: Ref<bevy::math::UVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::UVec3::as_dvec3(&_self).into();
+        output
+    }
+    fn as_i64vec3(_self: Ref<bevy::math::UVec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::UVec3::as_i64vec3(&_self)
+            .into();
+        output
+    }
+    fn as_ivec3(_self: Ref<bevy::math::UVec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::UVec3::as_ivec3(&_self).into();
+        output
+    }
+    fn as_u64vec3(_self: Ref<bevy::math::UVec3>) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::UVec3::as_u64vec3(&_self)
+            .into();
+        output
+    }
+    fn as_vec3(_self: Ref<bevy::math::UVec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::UVec3::as_vec3(&_self).into();
+        output
+    }
+    fn as_vec3a(_self: Ref<bevy::math::UVec3>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::UVec3::as_vec3a(&_self).into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::UVec3>) {
+        let output: () = <bevy::math::UVec3 as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clamp(
+        _self: Val<bevy::math::UVec3>,
+        min: Val<bevy::math::UVec3>,
+        max: Val<bevy::math::UVec3>,
+    ) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::clamp(
+                _self.into_inner(),
+                min.into_inner(),
+                max.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn cmpeq(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::UVec3::cmpeq(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpge(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::UVec3::cmpge(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpgt(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::UVec3::cmpgt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmple(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::UVec3::cmple(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmplt(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::UVec3::cmplt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpne(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::UVec3::cmpne(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cross(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::cross(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::UVec3>, rhs: Ref<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Div<
+            &bevy::math::UVec3,
+        >>::div(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Div<
+            bevy::math::UVec3,
+        >>::div(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::UVec3>, rhs: u32) {
+        let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Div<
+            u32,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: u32 = bevy::math::UVec3::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn dot_into_vec(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::dot_into_vec(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn element_product(_self: Val<bevy::math::UVec3>) {
+        let output: u32 = bevy::math::UVec3::element_product(_self.into_inner()).into();
+        output
+    }
+    fn element_sum(_self: Val<bevy::math::UVec3>) {
+        let output: u32 = bevy::math::UVec3::element_sum(_self.into_inner()).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::UVec3>, other: Ref<bevy::math::UVec3>) {
+        let output: bool = <bevy::math::UVec3 as std::cmp::PartialEq<
+            bevy::math::UVec3,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn extend(_self: Val<bevy::math::UVec3>, w: u32) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec3::extend(
+                _self.into_inner(),
+                w,
+            )
+            .into();
+        output
+    }
+    fn from_array(a: [u32; 3]) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::from_array(a).into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::UVec3>) {
+        let output: u32 = bevy::math::UVec3::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn max(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::max(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn max_element(_self: Val<bevy::math::UVec3>) {
+        let output: u32 = bevy::math::UVec3::max_element(_self.into_inner()).into();
+        output
+    }
+    fn min(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::min(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min_element(_self: Val<bevy::math::UVec3>) {
+        let output: u32 = bevy::math::UVec3::min_element(_self.into_inner()).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::UVec3>, rhs: Ref<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Mul<
+            &bevy::math::UVec3,
+        >>::mul(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Mul<
+            bevy::math::UVec3,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::UVec3>, rhs: u32) {
+        let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Mul<
+            u32,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn new(x: u32, y: u32, z: u32) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::new(x, y, z).into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::UVec3>, rhs: Ref<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Rem<
+            &bevy::math::UVec3,
+        >>::rem(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Rem<
+            bevy::math::UVec3,
+        >>::rem(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::UVec3>, rhs: u32) {
+        let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Rem<
+            u32,
+        >>::rem(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn saturating_add(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::saturating_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_add_signed(
+        _self: Val<bevy::math::UVec3>,
+        rhs: Val<bevy::math::IVec3>,
+    ) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::saturating_add_signed(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_div(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::saturating_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_mul(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::saturating_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_sub(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::saturating_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn select(
+        mask: Val<bevy::math::BVec3>,
+        if_true: Val<bevy::math::UVec3>,
+        if_false: Val<bevy::math::UVec3>,
+    ) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::select(
+                mask.into_inner(),
+                if_true.into_inner(),
+                if_false.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn splat(v: u32) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::splat(v).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::UVec3>, rhs: Ref<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Sub<
+            &bevy::math::UVec3,
+        >>::sub(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Sub<
+            bevy::math::UVec3,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::UVec3>, rhs: u32) {
+        let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Sub<
+            u32,
+        >>::sub(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::UVec3>) {
+        let output: [u32; 3] = bevy::math::UVec3::to_array(&_self).into();
+        output
+    }
+    fn truncate(_self: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec2> = bevy::math::UVec3::truncate(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn with_x(_self: Val<bevy::math::UVec3>, x: u32) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::with_x(
+                _self.into_inner(),
+                x,
+            )
+            .into();
+        output
+    }
+    fn with_y(_self: Val<bevy::math::UVec3>, y: u32) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::with_y(
+                _self.into_inner(),
+                y,
+            )
+            .into();
+        output
+    }
+    fn with_z(_self: Val<bevy::math::UVec3>, z: u32) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::with_z(
+                _self.into_inner(),
+                z,
+            )
+            .into();
+        output
+    }
+    fn wrapping_add(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::wrapping_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_add_signed(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::IVec3>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::wrapping_add_signed(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_div(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::wrapping_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_mul(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::wrapping_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_sub(_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec3::wrapping_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "u_vec_4")]
+impl bevy::math::UVec4 {
+    fn add(_self: Val<bevy::math::UVec4>, rhs: Ref<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Add<
+            &bevy::math::UVec4,
+        >>::add(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Add<
+            bevy::math::UVec4,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::UVec4>, rhs: u32) {
+        let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Add<
+            u32,
+        >>::add(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn as_dvec4(_self: Ref<bevy::math::UVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::UVec4::as_dvec4(&_self).into();
+        output
+    }
+    fn as_i64vec4(_self: Ref<bevy::math::UVec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::UVec4::as_i64vec4(&_self)
+            .into();
+        output
+    }
+    fn as_ivec4(_self: Ref<bevy::math::UVec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::UVec4::as_ivec4(&_self).into();
+        output
+    }
+    fn as_u64vec4(_self: Ref<bevy::math::UVec4>) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::UVec4::as_u64vec4(&_self)
+            .into();
+        output
+    }
+    fn as_vec4(_self: Ref<bevy::math::UVec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::UVec4::as_vec4(&_self).into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::UVec4>) {
+        let output: () = <bevy::math::UVec4 as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clamp(
+        _self: Val<bevy::math::UVec4>,
+        min: Val<bevy::math::UVec4>,
+        max: Val<bevy::math::UVec4>,
+    ) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::clamp(
+                _self.into_inner(),
+                min.into_inner(),
+                max.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn cmpeq(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::UVec4::cmpeq(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpge(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::UVec4::cmpge(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpgt(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::UVec4::cmpgt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmple(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::UVec4::cmple(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmplt(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::UVec4::cmplt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpne(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::UVec4::cmpne(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::UVec4>, rhs: Ref<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Div<
+            &bevy::math::UVec4,
+        >>::div(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Div<
+            bevy::math::UVec4,
+        >>::div(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::UVec4>, rhs: u32) {
+        let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Div<
+            u32,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: u32 = bevy::math::UVec4::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn dot_into_vec(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::dot_into_vec(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn element_product(_self: Val<bevy::math::UVec4>) {
+        let output: u32 = bevy::math::UVec4::element_product(_self.into_inner()).into();
+        output
+    }
+    fn element_sum(_self: Val<bevy::math::UVec4>) {
+        let output: u32 = bevy::math::UVec4::element_sum(_self.into_inner()).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::UVec4>, other: Ref<bevy::math::UVec4>) {
+        let output: bool = <bevy::math::UVec4 as std::cmp::PartialEq<
+            bevy::math::UVec4,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_array(a: [u32; 4]) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::from_array(a).into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::UVec4>) {
+        let output: u32 = bevy::math::UVec4::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn max(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::max(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn max_element(_self: Val<bevy::math::UVec4>) {
+        let output: u32 = bevy::math::UVec4::max_element(_self.into_inner()).into();
+        output
+    }
+    fn min(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::min(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min_element(_self: Val<bevy::math::UVec4>) {
+        let output: u32 = bevy::math::UVec4::min_element(_self.into_inner()).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::UVec4>, rhs: Ref<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Mul<
+            &bevy::math::UVec4,
+        >>::mul(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Mul<
+            bevy::math::UVec4,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::UVec4>, rhs: u32) {
+        let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Mul<
+            u32,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn new(x: u32, y: u32, z: u32, w: u32) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::new(x, y, z, w).into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::UVec4>, rhs: Ref<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Rem<
+            &bevy::math::UVec4,
+        >>::rem(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Rem<
+            bevy::math::UVec4,
+        >>::rem(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::UVec4>, rhs: u32) {
+        let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Rem<
+            u32,
+        >>::rem(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn saturating_add(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::saturating_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_add_signed(
+        _self: Val<bevy::math::UVec4>,
+        rhs: Val<bevy::math::IVec4>,
+    ) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::saturating_add_signed(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_div(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::saturating_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_mul(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::saturating_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_sub(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::saturating_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn select(
+        mask: Val<bevy::math::BVec4>,
+        if_true: Val<bevy::math::UVec4>,
+        if_false: Val<bevy::math::UVec4>,
+    ) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::select(
+                mask.into_inner(),
+                if_true.into_inner(),
+                if_false.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn splat(v: u32) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::splat(v).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::UVec4>, rhs: Ref<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Sub<
+            &bevy::math::UVec4,
+        >>::sub(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Sub<
+            bevy::math::UVec4,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::UVec4>, rhs: u32) {
+        let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Sub<
+            u32,
+        >>::sub(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::UVec4>) {
+        let output: [u32; 4] = bevy::math::UVec4::to_array(&_self).into();
+        output
+    }
+    fn truncate(_self: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::UVec4::truncate(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn with_w(_self: Val<bevy::math::UVec4>, w: u32) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::with_w(
+                _self.into_inner(),
+                w,
+            )
+            .into();
+        output
+    }
+    fn with_x(_self: Val<bevy::math::UVec4>, x: u32) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::with_x(
+                _self.into_inner(),
+                x,
+            )
+            .into();
+        output
+    }
+    fn with_y(_self: Val<bevy::math::UVec4>, y: u32) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::with_y(
+                _self.into_inner(),
+                y,
+            )
+            .into();
+        output
+    }
+    fn with_z(_self: Val<bevy::math::UVec4>, z: u32) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::with_z(
+                _self.into_inner(),
+                z,
+            )
+            .into();
+        output
+    }
+    fn wrapping_add(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::wrapping_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_add_signed(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::IVec4>) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::wrapping_add_signed(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_div(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::wrapping_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_mul(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::wrapping_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_sub(_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>) {
+        let output: Val<bevy::math::UVec4> = bevy::math::UVec4::wrapping_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "u_64_vec_2")]
+impl bevy::math::U64Vec2 {
+    fn add(_self: Val<bevy::math::U64Vec2>, rhs: Ref<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Add<
+            &bevy::math::U64Vec2,
+        >>::add(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Add<
+            bevy::math::U64Vec2,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::U64Vec2>, rhs: u64) {
+        let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Add<
+            u64,
+        >>::add(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn as_dvec2(_self: Ref<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::U64Vec2::as_dvec2(&_self)
+            .into();
+        output
+    }
+    fn as_i64vec2(_self: Ref<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::U64Vec2::as_i64vec2(&_self)
+            .into();
+        output
+    }
+    fn as_ivec2(_self: Ref<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::U64Vec2::as_ivec2(&_self)
+            .into();
+        output
+    }
+    fn as_uvec2(_self: Ref<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::UVec2> = bevy::math::U64Vec2::as_uvec2(&_self)
+            .into();
+        output
+    }
+    fn as_vec2(_self: Ref<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::U64Vec2::as_vec2(&_self).into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::U64Vec2>) {
+        let output: () = <bevy::math::U64Vec2 as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clamp(
+        _self: Val<bevy::math::U64Vec2>,
+        min: Val<bevy::math::U64Vec2>,
+        max: Val<bevy::math::U64Vec2>,
+    ) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::clamp(
+                _self.into_inner(),
+                min.into_inner(),
+                max.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn cmpeq(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::U64Vec2::cmpeq(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpge(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::U64Vec2::cmpge(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpgt(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::U64Vec2::cmpgt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmple(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::U64Vec2::cmple(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmplt(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::U64Vec2::cmplt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpne(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::U64Vec2::cmpne(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::U64Vec2>, rhs: Ref<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Div<
+            &bevy::math::U64Vec2,
+        >>::div(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Div<
+            bevy::math::U64Vec2,
+        >>::div(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::U64Vec2>, rhs: u64) {
+        let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Div<
+            u64,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: u64 = bevy::math::U64Vec2::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn dot_into_vec(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::dot_into_vec(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn element_product(_self: Val<bevy::math::U64Vec2>) {
+        let output: u64 = bevy::math::U64Vec2::element_product(_self.into_inner())
+            .into();
+        output
+    }
+    fn element_sum(_self: Val<bevy::math::U64Vec2>) {
+        let output: u64 = bevy::math::U64Vec2::element_sum(_self.into_inner()).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::U64Vec2>, other: Ref<bevy::math::U64Vec2>) {
+        let output: bool = <bevy::math::U64Vec2 as std::cmp::PartialEq<
+            bevy::math::U64Vec2,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn extend(_self: Val<bevy::math::U64Vec2>, z: u64) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec2::extend(
+                _self.into_inner(),
+                z,
+            )
+            .into();
+        output
+    }
+    fn from_array(a: [u64; 2]) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::from_array(a).into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::U64Vec2>) {
+        let output: u64 = bevy::math::U64Vec2::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn max(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::max(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn max_element(_self: Val<bevy::math::U64Vec2>) {
+        let output: u64 = bevy::math::U64Vec2::max_element(_self.into_inner()).into();
+        output
+    }
+    fn min(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::min(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min_element(_self: Val<bevy::math::U64Vec2>) {
+        let output: u64 = bevy::math::U64Vec2::min_element(_self.into_inner()).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::U64Vec2>, rhs: Ref<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Mul<
+            &bevy::math::U64Vec2,
+        >>::mul(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Mul<
+            bevy::math::U64Vec2,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::U64Vec2>, rhs: u64) {
+        let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Mul<
+            u64,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn new(x: u64, y: u64) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::new(x, y).into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::U64Vec2>, rhs: Ref<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Rem<
+            &bevy::math::U64Vec2,
+        >>::rem(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Rem<
+            bevy::math::U64Vec2,
+        >>::rem(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::U64Vec2>, rhs: u64) {
+        let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Rem<
+            u64,
+        >>::rem(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn saturating_add(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::saturating_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_add_signed(
+        _self: Val<bevy::math::U64Vec2>,
+        rhs: Val<bevy::math::I64Vec2>,
+    ) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::saturating_add_signed(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_div(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::saturating_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_mul(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::saturating_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_sub(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::saturating_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn select(
+        mask: Val<bevy::math::BVec2>,
+        if_true: Val<bevy::math::U64Vec2>,
+        if_false: Val<bevy::math::U64Vec2>,
+    ) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::select(
+                mask.into_inner(),
+                if_true.into_inner(),
+                if_false.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn splat(v: u64) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::splat(v).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::U64Vec2>, rhs: Ref<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Sub<
+            &bevy::math::U64Vec2,
+        >>::sub(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Sub<
+            bevy::math::U64Vec2,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::U64Vec2>, rhs: u64) {
+        let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Sub<
+            u64,
+        >>::sub(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::U64Vec2>) {
+        let output: [u64; 2] = bevy::math::U64Vec2::to_array(&_self).into();
+        output
+    }
+    fn with_x(_self: Val<bevy::math::U64Vec2>, x: u64) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::with_x(
+                _self.into_inner(),
+                x,
+            )
+            .into();
+        output
+    }
+    fn with_y(_self: Val<bevy::math::U64Vec2>, y: u64) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::with_y(
+                _self.into_inner(),
+                y,
+            )
+            .into();
+        output
+    }
+    fn wrapping_add(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::wrapping_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_add_signed(
+        _self: Val<bevy::math::U64Vec2>,
+        rhs: Val<bevy::math::I64Vec2>,
+    ) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::wrapping_add_signed(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_div(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::wrapping_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_mul(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::wrapping_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_sub(_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::wrapping_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "u_64_vec_3")]
+impl bevy::math::U64Vec3 {
+    fn add(_self: Val<bevy::math::U64Vec3>, rhs: Ref<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Add<
+            &bevy::math::U64Vec3,
+        >>::add(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Add<
+            bevy::math::U64Vec3,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::U64Vec3>, rhs: u64) {
+        let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Add<
+            u64,
+        >>::add(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn as_dvec3(_self: Ref<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::U64Vec3::as_dvec3(&_self)
+            .into();
+        output
+    }
+    fn as_i64vec3(_self: Ref<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::U64Vec3::as_i64vec3(&_self)
+            .into();
+        output
+    }
+    fn as_ivec3(_self: Ref<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::U64Vec3::as_ivec3(&_self)
+            .into();
+        output
+    }
+    fn as_uvec3(_self: Ref<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::U64Vec3::as_uvec3(&_self)
+            .into();
+        output
+    }
+    fn as_vec3(_self: Ref<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::U64Vec3::as_vec3(&_self).into();
+        output
+    }
+    fn as_vec3a(_self: Ref<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::U64Vec3::as_vec3a(&_self)
+            .into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::U64Vec3>) {
+        let output: () = <bevy::math::U64Vec3 as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clamp(
+        _self: Val<bevy::math::U64Vec3>,
+        min: Val<bevy::math::U64Vec3>,
+        max: Val<bevy::math::U64Vec3>,
+    ) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::clamp(
+                _self.into_inner(),
+                min.into_inner(),
+                max.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn cmpeq(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::U64Vec3::cmpeq(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpge(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::U64Vec3::cmpge(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpgt(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::U64Vec3::cmpgt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmple(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::U64Vec3::cmple(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmplt(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::U64Vec3::cmplt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpne(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::U64Vec3::cmpne(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cross(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::cross(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::U64Vec3>, rhs: Ref<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Div<
+            &bevy::math::U64Vec3,
+        >>::div(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Div<
+            bevy::math::U64Vec3,
+        >>::div(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::U64Vec3>, rhs: u64) {
+        let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Div<
+            u64,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: u64 = bevy::math::U64Vec3::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn dot_into_vec(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::dot_into_vec(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn element_product(_self: Val<bevy::math::U64Vec3>) {
+        let output: u64 = bevy::math::U64Vec3::element_product(_self.into_inner())
+            .into();
+        output
+    }
+    fn element_sum(_self: Val<bevy::math::U64Vec3>) {
+        let output: u64 = bevy::math::U64Vec3::element_sum(_self.into_inner()).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::U64Vec3>, other: Ref<bevy::math::U64Vec3>) {
+        let output: bool = <bevy::math::U64Vec3 as std::cmp::PartialEq<
+            bevy::math::U64Vec3,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn extend(_self: Val<bevy::math::U64Vec3>, w: u64) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec3::extend(
+                _self.into_inner(),
+                w,
+            )
+            .into();
+        output
+    }
+    fn from_array(a: [u64; 3]) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::from_array(a).into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::U64Vec3>) {
+        let output: u64 = bevy::math::U64Vec3::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn max(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::max(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn max_element(_self: Val<bevy::math::U64Vec3>) {
+        let output: u64 = bevy::math::U64Vec3::max_element(_self.into_inner()).into();
+        output
+    }
+    fn min(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::min(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min_element(_self: Val<bevy::math::U64Vec3>) {
+        let output: u64 = bevy::math::U64Vec3::min_element(_self.into_inner()).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::U64Vec3>, rhs: Ref<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Mul<
+            &bevy::math::U64Vec3,
+        >>::mul(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Mul<
+            bevy::math::U64Vec3,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::U64Vec3>, rhs: u64) {
+        let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Mul<
+            u64,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn new(x: u64, y: u64, z: u64) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::new(x, y, z).into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::U64Vec3>, rhs: Ref<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Rem<
+            &bevy::math::U64Vec3,
+        >>::rem(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Rem<
+            bevy::math::U64Vec3,
+        >>::rem(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::U64Vec3>, rhs: u64) {
+        let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Rem<
+            u64,
+        >>::rem(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn saturating_add(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::saturating_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_add_signed(
+        _self: Val<bevy::math::U64Vec3>,
+        rhs: Val<bevy::math::I64Vec3>,
+    ) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::saturating_add_signed(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_div(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::saturating_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_mul(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::saturating_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_sub(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::saturating_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn select(
+        mask: Val<bevy::math::BVec3>,
+        if_true: Val<bevy::math::U64Vec3>,
+        if_false: Val<bevy::math::U64Vec3>,
+    ) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::select(
+                mask.into_inner(),
+                if_true.into_inner(),
+                if_false.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn splat(v: u64) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::splat(v).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::U64Vec3>, rhs: Ref<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Sub<
+            &bevy::math::U64Vec3,
+        >>::sub(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Sub<
+            bevy::math::U64Vec3,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::U64Vec3>, rhs: u64) {
+        let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Sub<
+            u64,
+        >>::sub(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::U64Vec3>) {
+        let output: [u64; 3] = bevy::math::U64Vec3::to_array(&_self).into();
+        output
+    }
+    fn truncate(_self: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec3::truncate(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn with_x(_self: Val<bevy::math::U64Vec3>, x: u64) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::with_x(
+                _self.into_inner(),
+                x,
+            )
+            .into();
+        output
+    }
+    fn with_y(_self: Val<bevy::math::U64Vec3>, y: u64) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::with_y(
+                _self.into_inner(),
+                y,
+            )
+            .into();
+        output
+    }
+    fn with_z(_self: Val<bevy::math::U64Vec3>, z: u64) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::with_z(
+                _self.into_inner(),
+                z,
+            )
+            .into();
+        output
+    }
+    fn wrapping_add(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::wrapping_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_add_signed(
+        _self: Val<bevy::math::U64Vec3>,
+        rhs: Val<bevy::math::I64Vec3>,
+    ) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::wrapping_add_signed(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_div(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::wrapping_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_mul(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::wrapping_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_sub(_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::wrapping_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "u_64_vec_4")]
+impl bevy::math::U64Vec4 {
+    fn add(_self: Val<bevy::math::U64Vec4>, rhs: Ref<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Add<
+            &bevy::math::U64Vec4,
+        >>::add(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Add<
+            bevy::math::U64Vec4,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::U64Vec4>, rhs: u64) {
+        let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Add<
+            u64,
+        >>::add(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn as_dvec4(_self: Ref<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::U64Vec4::as_dvec4(&_self)
+            .into();
+        output
+    }
+    fn as_i64vec4(_self: Ref<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::U64Vec4::as_i64vec4(&_self)
+            .into();
+        output
+    }
+    fn as_ivec4(_self: Ref<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::U64Vec4::as_ivec4(&_self)
+            .into();
+        output
+    }
+    fn as_uvec4(_self: Ref<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::UVec4> = bevy::math::U64Vec4::as_uvec4(&_self)
+            .into();
+        output
+    }
+    fn as_vec4(_self: Ref<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::U64Vec4::as_vec4(&_self).into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::U64Vec4>) {
+        let output: () = <bevy::math::U64Vec4 as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clamp(
+        _self: Val<bevy::math::U64Vec4>,
+        min: Val<bevy::math::U64Vec4>,
+        max: Val<bevy::math::U64Vec4>,
+    ) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::clamp(
+                _self.into_inner(),
+                min.into_inner(),
+                max.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn cmpeq(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::U64Vec4::cmpeq(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpge(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::U64Vec4::cmpge(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpgt(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::U64Vec4::cmpgt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmple(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::U64Vec4::cmple(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmplt(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::U64Vec4::cmplt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpne(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::U64Vec4::cmpne(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::U64Vec4>, rhs: Ref<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Div<
+            &bevy::math::U64Vec4,
+        >>::div(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Div<
+            bevy::math::U64Vec4,
+        >>::div(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::U64Vec4>, rhs: u64) {
+        let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Div<
+            u64,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: u64 = bevy::math::U64Vec4::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn dot_into_vec(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::dot_into_vec(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn element_product(_self: Val<bevy::math::U64Vec4>) {
+        let output: u64 = bevy::math::U64Vec4::element_product(_self.into_inner())
+            .into();
+        output
+    }
+    fn element_sum(_self: Val<bevy::math::U64Vec4>) {
+        let output: u64 = bevy::math::U64Vec4::element_sum(_self.into_inner()).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::U64Vec4>, other: Ref<bevy::math::U64Vec4>) {
+        let output: bool = <bevy::math::U64Vec4 as std::cmp::PartialEq<
+            bevy::math::U64Vec4,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_array(a: [u64; 4]) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::from_array(a).into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::U64Vec4>) {
+        let output: u64 = bevy::math::U64Vec4::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn max(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::max(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn max_element(_self: Val<bevy::math::U64Vec4>) {
+        let output: u64 = bevy::math::U64Vec4::max_element(_self.into_inner()).into();
+        output
+    }
+    fn min(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::min(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min_element(_self: Val<bevy::math::U64Vec4>) {
+        let output: u64 = bevy::math::U64Vec4::min_element(_self.into_inner()).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::U64Vec4>, rhs: Ref<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Mul<
+            &bevy::math::U64Vec4,
+        >>::mul(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Mul<
+            bevy::math::U64Vec4,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::U64Vec4>, rhs: u64) {
+        let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Mul<
+            u64,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn new(x: u64, y: u64, z: u64, w: u64) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::new(x, y, z, w)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::U64Vec4>, rhs: Ref<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Rem<
+            &bevy::math::U64Vec4,
+        >>::rem(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Rem<
+            bevy::math::U64Vec4,
+        >>::rem(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::U64Vec4>, rhs: u64) {
+        let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Rem<
+            u64,
+        >>::rem(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn saturating_add(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::saturating_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_add_signed(
+        _self: Val<bevy::math::U64Vec4>,
+        rhs: Val<bevy::math::I64Vec4>,
+    ) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::saturating_add_signed(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_div(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::saturating_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_mul(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::saturating_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn saturating_sub(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::saturating_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn select(
+        mask: Val<bevy::math::BVec4>,
+        if_true: Val<bevy::math::U64Vec4>,
+        if_false: Val<bevy::math::U64Vec4>,
+    ) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::select(
+                mask.into_inner(),
+                if_true.into_inner(),
+                if_false.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn splat(v: u64) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::splat(v).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::U64Vec4>, rhs: Ref<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Sub<
+            &bevy::math::U64Vec4,
+        >>::sub(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Sub<
+            bevy::math::U64Vec4,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::U64Vec4>, rhs: u64) {
+        let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Sub<
+            u64,
+        >>::sub(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::U64Vec4>) {
+        let output: [u64; 4] = bevy::math::U64Vec4::to_array(&_self).into();
+        output
+    }
+    fn truncate(_self: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec4::truncate(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn with_w(_self: Val<bevy::math::U64Vec4>, w: u64) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::with_w(
+                _self.into_inner(),
+                w,
+            )
+            .into();
+        output
+    }
+    fn with_x(_self: Val<bevy::math::U64Vec4>, x: u64) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::with_x(
+                _self.into_inner(),
+                x,
+            )
+            .into();
+        output
+    }
+    fn with_y(_self: Val<bevy::math::U64Vec4>, y: u64) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::with_y(
+                _self.into_inner(),
+                y,
+            )
+            .into();
+        output
+    }
+    fn with_z(_self: Val<bevy::math::U64Vec4>, z: u64) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::with_z(
+                _self.into_inner(),
+                z,
+            )
+            .into();
+        output
+    }
+    fn wrapping_add(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::wrapping_add(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_add_signed(
+        _self: Val<bevy::math::U64Vec4>,
+        rhs: Val<bevy::math::I64Vec4>,
+    ) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::wrapping_add_signed(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_div(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::wrapping_div(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_mul(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::wrapping_mul(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn wrapping_sub(_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::wrapping_sub(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "vec_2")]
+impl bevy::math::Vec2 {
+    fn abs(_self: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::abs(_self.into_inner())
+            .into();
+        output
+    }
+    fn abs_diff_eq(
+        _self: Val<bevy::math::Vec2>,
+        rhs: Val<bevy::math::Vec2>,
+        max_abs_diff: f32,
+    ) {
+        let output: bool = bevy::math::Vec2::abs_diff_eq(
+                _self.into_inner(),
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::Vec2>, rhs: Ref<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Add<
+            &bevy::math::Vec2,
+        >>::add(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Add<
+            bevy::math::Vec2,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::Vec2>, rhs: f32) {
+        let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Add<
+            f32,
+        >>::add(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn angle_between(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: f32 = bevy::math::Vec2::angle_between(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn angle_to(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: f32 = bevy::math::Vec2::angle_to(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn as_dvec2(_self: Ref<bevy::math::Vec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::Vec2::as_dvec2(&_self).into();
+        output
+    }
+    fn as_i64vec2(_self: Ref<bevy::math::Vec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::Vec2::as_i64vec2(&_self)
+            .into();
+        output
+    }
+    fn as_ivec2(_self: Ref<bevy::math::Vec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::Vec2::as_ivec2(&_self).into();
+        output
+    }
+    fn as_u64vec2(_self: Ref<bevy::math::Vec2>) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::Vec2::as_u64vec2(&_self)
+            .into();
+        output
+    }
+    fn as_uvec2(_self: Ref<bevy::math::Vec2>) {
+        let output: Val<bevy::math::UVec2> = bevy::math::Vec2::as_uvec2(&_self).into();
+        output
+    }
+    fn ceil(_self: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::ceil(_self.into_inner())
+            .into();
+        output
+    }
+    fn clamp(
+        _self: Val<bevy::math::Vec2>,
+        min: Val<bevy::math::Vec2>,
+        max: Val<bevy::math::Vec2>,
+    ) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::clamp(
+                _self.into_inner(),
+                min.into_inner(),
+                max.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clamp_length(_self: Val<bevy::math::Vec2>, min: f32, max: f32) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::clamp_length(
+                _self.into_inner(),
+                min,
+                max,
+            )
+            .into();
+        output
+    }
+    fn clamp_length_max(_self: Val<bevy::math::Vec2>, max: f32) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::clamp_length_max(
+                _self.into_inner(),
+                max,
+            )
+            .into();
+        output
+    }
+    fn clamp_length_min(_self: Val<bevy::math::Vec2>, min: f32) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::clamp_length_min(
+                _self.into_inner(),
+                min,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn cmpeq(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::Vec2::cmpeq(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpge(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::Vec2::cmpge(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpgt(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::Vec2::cmpgt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmple(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::Vec2::cmple(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmplt(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::Vec2::cmplt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpne(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::Vec2::cmpne(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn copysign(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::copysign(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: f32 = bevy::math::Vec2::distance(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance_squared(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: f32 = bevy::math::Vec2::distance_squared(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::Vec2>, rhs: Ref<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Div<
+            &bevy::math::Vec2,
+        >>::div(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Div<
+            bevy::math::Vec2,
+        >>::div(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::Vec2>, rhs: f32) {
+        let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Div<
+            f32,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_euclid(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::div_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: f32 = bevy::math::Vec2::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn dot_into_vec(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::dot_into_vec(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn element_product(_self: Val<bevy::math::Vec2>) {
+        let output: f32 = bevy::math::Vec2::element_product(_self.into_inner()).into();
+        output
+    }
+    fn element_sum(_self: Val<bevy::math::Vec2>) {
+        let output: f32 = bevy::math::Vec2::element_sum(_self.into_inner()).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::Vec2>, other: Ref<bevy::math::Vec2>) {
+        let output: bool = <bevy::math::Vec2 as std::cmp::PartialEq<
+            bevy::math::Vec2,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn exp(_self: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::exp(_self.into_inner())
+            .into();
+        output
+    }
+    fn extend(_self: Val<bevy::math::Vec2>, z: f32) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec2::extend(
+                _self.into_inner(),
+                z,
+            )
+            .into();
+        output
+    }
+    fn floor(_self: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::floor(_self.into_inner())
+            .into();
+        output
+    }
+    fn fract(_self: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::fract(_self.into_inner())
+            .into();
+        output
+    }
+    fn fract_gl(_self: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::fract_gl(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_angle(angle: f32) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::from_angle(angle).into();
+        output
+    }
+    fn from_array(a: [f32; 2]) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::from_array(a).into();
+        output
+    }
+    fn is_finite(_self: Val<bevy::math::Vec2>) {
+        let output: bool = bevy::math::Vec2::is_finite(_self.into_inner()).into();
+        output
+    }
+    fn is_finite_mask(_self: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::Vec2::is_finite_mask(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn is_nan(_self: Val<bevy::math::Vec2>) {
+        let output: bool = bevy::math::Vec2::is_nan(_self.into_inner()).into();
+        output
+    }
+    fn is_nan_mask(_self: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::Vec2::is_nan_mask(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn is_negative_bitmask(_self: Val<bevy::math::Vec2>) {
+        let output: u32 = bevy::math::Vec2::is_negative_bitmask(_self.into_inner())
+            .into();
+        output
+    }
+    fn is_normalized(_self: Val<bevy::math::Vec2>) {
+        let output: bool = bevy::math::Vec2::is_normalized(_self.into_inner()).into();
+        output
+    }
+    fn length(_self: Val<bevy::math::Vec2>) {
+        let output: f32 = bevy::math::Vec2::length(_self.into_inner()).into();
+        output
+    }
+    fn length_recip(_self: Val<bevy::math::Vec2>) {
+        let output: f32 = bevy::math::Vec2::length_recip(_self.into_inner()).into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::Vec2>) {
+        let output: f32 = bevy::math::Vec2::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn lerp(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>, s: f32) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::lerp(
+                _self.into_inner(),
+                rhs.into_inner(),
+                s,
+            )
+            .into();
+        output
+    }
+    fn max(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::max(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn max_element(_self: Val<bevy::math::Vec2>) {
+        let output: f32 = bevy::math::Vec2::max_element(_self.into_inner()).into();
+        output
+    }
+    fn midpoint(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::midpoint(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::min(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min_element(_self: Val<bevy::math::Vec2>) {
+        let output: f32 = bevy::math::Vec2::min_element(_self.into_inner()).into();
+        output
+    }
+    fn move_towards(_self: Ref<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>, d: f32) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::move_towards(
+                &_self,
+                rhs.into_inner(),
+                d,
+            )
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Vec2>, rhs: Ref<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Mul<
+            &bevy::math::Vec2,
+        >>::mul(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Mul<
+            bevy::math::Vec2,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Vec2>, rhs: f32) {
+        let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Mul<
+            f32,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn mul_add(
+        _self: Val<bevy::math::Vec2>,
+        a: Val<bevy::math::Vec2>,
+        b: Val<bevy::math::Vec2>,
+    ) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::mul_add(
+                _self.into_inner(),
+                a.into_inner(),
+                b.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(x: f32, y: f32) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::new(x, y).into();
+        output
+    }
+    fn normalize(_self: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::normalize(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn normalize_or(_self: Val<bevy::math::Vec2>, fallback: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::normalize_or(
+                _self.into_inner(),
+                fallback.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn normalize_or_zero(_self: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::normalize_or_zero(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn perp(_self: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::perp(_self.into_inner())
+            .into();
+        output
+    }
+    fn perp_dot(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: f32 = bevy::math::Vec2::perp_dot(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn powf(_self: Val<bevy::math::Vec2>, n: f32) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::powf(_self.into_inner(), n)
+            .into();
+        output
+    }
+    fn project_onto(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::project_onto(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn project_onto_normalized(
+        _self: Val<bevy::math::Vec2>,
+        rhs: Val<bevy::math::Vec2>,
+    ) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::project_onto_normalized(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn recip(_self: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::recip(_self.into_inner())
+            .into();
+        output
+    }
+    fn reflect(_self: Val<bevy::math::Vec2>, normal: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::reflect(
+                _self.into_inner(),
+                normal.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn refract(_self: Val<bevy::math::Vec2>, normal: Val<bevy::math::Vec2>, eta: f32) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::refract(
+                _self.into_inner(),
+                normal.into_inner(),
+                eta,
+            )
+            .into();
+        output
+    }
+    fn reject_from(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::reject_from(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn reject_from_normalized(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::reject_from_normalized(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::Vec2>, rhs: Ref<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Rem<
+            &bevy::math::Vec2,
+        >>::rem(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Rem<
+            bevy::math::Vec2,
+        >>::rem(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::Vec2>, rhs: f32) {
+        let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Rem<
+            f32,
+        >>::rem(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn rem_euclid(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::rem_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rotate(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::rotate(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rotate_towards(
+        _self: Ref<bevy::math::Vec2>,
+        rhs: Val<bevy::math::Vec2>,
+        max_angle: f32,
+    ) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::rotate_towards(
+                &_self,
+                rhs.into_inner(),
+                max_angle,
+            )
+            .into();
+        output
+    }
+    fn round(_self: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::round(_self.into_inner())
+            .into();
+        output
+    }
+    fn select(
+        mask: Val<bevy::math::BVec2>,
+        if_true: Val<bevy::math::Vec2>,
+        if_false: Val<bevy::math::Vec2>,
+    ) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::select(
+                mask.into_inner(),
+                if_true.into_inner(),
+                if_false.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn signum(_self: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::signum(_self.into_inner())
+            .into();
+        output
+    }
+    fn splat(v: f32) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::splat(v).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::Vec2>, rhs: Ref<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Sub<
+            &bevy::math::Vec2,
+        >>::sub(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Sub<
+            bevy::math::Vec2,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::Vec2>, rhs: f32) {
+        let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Sub<
+            f32,
+        >>::sub(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn to_angle(_self: Val<bevy::math::Vec2>) {
+        let output: f32 = bevy::math::Vec2::to_angle(_self.into_inner()).into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::Vec2>) {
+        let output: [f32; 2] = bevy::math::Vec2::to_array(&_self).into();
+        output
+    }
+    fn trunc(_self: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::trunc(_self.into_inner())
+            .into();
+        output
+    }
+    fn with_x(_self: Val<bevy::math::Vec2>, x: f32) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::with_x(
+                _self.into_inner(),
+                x,
+            )
+            .into();
+        output
+    }
+    fn with_y(_self: Val<bevy::math::Vec2>, y: f32) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec2::with_y(
+                _self.into_inner(),
+                y,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "vec_3_a")]
+impl bevy::math::Vec3A {
+    fn abs(_self: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::abs(_self.into_inner())
+            .into();
+        output
+    }
+    fn abs_diff_eq(
+        _self: Val<bevy::math::Vec3A>,
+        rhs: Val<bevy::math::Vec3A>,
+        max_abs_diff: f32,
+    ) {
+        let output: bool = bevy::math::Vec3A::abs_diff_eq(
+                _self.into_inner(),
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::Vec3A>, rhs: Ref<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Add<
+            &bevy::math::Vec3A,
+        >>::add(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Add<
+            bevy::math::Vec3A,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::Vec3A>, rhs: f32) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Add<
+            f32,
+        >>::add(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn angle_between(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: f32 = bevy::math::Vec3A::angle_between(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn any_orthogonal_vector(_self: Ref<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::any_orthogonal_vector(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn any_orthonormal_vector(_self: Ref<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::any_orthonormal_vector(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn as_dvec3(_self: Ref<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::Vec3A::as_dvec3(&_self).into();
+        output
+    }
+    fn as_i64vec3(_self: Ref<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::Vec3A::as_i64vec3(&_self)
+            .into();
+        output
+    }
+    fn as_ivec3(_self: Ref<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::Vec3A::as_ivec3(&_self).into();
+        output
+    }
+    fn as_u64vec3(_self: Ref<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::Vec3A::as_u64vec3(&_self)
+            .into();
+        output
+    }
+    fn as_uvec3(_self: Ref<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::Vec3A::as_uvec3(&_self).into();
+        output
+    }
+    fn ceil(_self: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::ceil(_self.into_inner())
+            .into();
+        output
+    }
+    fn clamp(
+        _self: Val<bevy::math::Vec3A>,
+        min: Val<bevy::math::Vec3A>,
+        max: Val<bevy::math::Vec3A>,
+    ) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::clamp(
+                _self.into_inner(),
+                min.into_inner(),
+                max.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clamp_length(_self: Val<bevy::math::Vec3A>, min: f32, max: f32) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::clamp_length(
+                _self.into_inner(),
+                min,
+                max,
+            )
+            .into();
+        output
+    }
+    fn clamp_length_max(_self: Val<bevy::math::Vec3A>, max: f32) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::clamp_length_max(
+                _self.into_inner(),
+                max,
+            )
+            .into();
+        output
+    }
+    fn clamp_length_min(_self: Val<bevy::math::Vec3A>, min: f32) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::clamp_length_min(
+                _self.into_inner(),
+                min,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn cmpeq(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::BVec3A> = bevy::math::Vec3A::cmpeq(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpge(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::BVec3A> = bevy::math::Vec3A::cmpge(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpgt(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::BVec3A> = bevy::math::Vec3A::cmpgt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmple(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::BVec3A> = bevy::math::Vec3A::cmple(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmplt(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::BVec3A> = bevy::math::Vec3A::cmplt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpne(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::BVec3A> = bevy::math::Vec3A::cmpne(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn copysign(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::copysign(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cross(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::cross(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: f32 = bevy::math::Vec3A::distance(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance_squared(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: f32 = bevy::math::Vec3A::distance_squared(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::Vec3A>, rhs: Ref<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Div<
+            &bevy::math::Vec3A,
+        >>::div(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Div<
+            bevy::math::Vec3A,
+        >>::div(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::Vec3A>, rhs: f32) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Div<
+            f32,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_euclid(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::div_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: f32 = bevy::math::Vec3A::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn dot_into_vec(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::dot_into_vec(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn element_product(_self: Val<bevy::math::Vec3A>) {
+        let output: f32 = bevy::math::Vec3A::element_product(_self.into_inner()).into();
+        output
+    }
+    fn element_sum(_self: Val<bevy::math::Vec3A>) {
+        let output: f32 = bevy::math::Vec3A::element_sum(_self.into_inner()).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::Vec3A>, rhs: Ref<bevy::math::Vec3A>) {
+        let output: bool = <bevy::math::Vec3A as std::cmp::PartialEq<
+            bevy::math::Vec3A,
+        >>::eq(&_self, &rhs)
+            .into();
+        output
+    }
+    fn exp(_self: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::exp(_self.into_inner())
+            .into();
+        output
+    }
+    fn extend(_self: Val<bevy::math::Vec3A>, w: f32) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec3A::extend(
+                _self.into_inner(),
+                w,
+            )
+            .into();
+        output
+    }
+    fn floor(_self: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::floor(_self.into_inner())
+            .into();
+        output
+    }
+    fn fract(_self: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::fract(_self.into_inner())
+            .into();
+        output
+    }
+    fn fract_gl(_self: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::fract_gl(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_array(a: [f32; 3]) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::from_array(a).into();
+        output
+    }
+    fn from_vec4(v: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::from_vec4(v.into_inner())
+            .into();
+        output
+    }
+    fn is_finite(_self: Val<bevy::math::Vec3A>) {
+        let output: bool = bevy::math::Vec3A::is_finite(_self.into_inner()).into();
+        output
+    }
+    fn is_finite_mask(_self: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::BVec3A> = bevy::math::Vec3A::is_finite_mask(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn is_nan(_self: Val<bevy::math::Vec3A>) {
+        let output: bool = bevy::math::Vec3A::is_nan(_self.into_inner()).into();
+        output
+    }
+    fn is_nan_mask(_self: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::BVec3A> = bevy::math::Vec3A::is_nan_mask(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn is_negative_bitmask(_self: Val<bevy::math::Vec3A>) {
+        let output: u32 = bevy::math::Vec3A::is_negative_bitmask(_self.into_inner())
+            .into();
+        output
+    }
+    fn is_normalized(_self: Val<bevy::math::Vec3A>) {
+        let output: bool = bevy::math::Vec3A::is_normalized(_self.into_inner()).into();
+        output
+    }
+    fn length(_self: Val<bevy::math::Vec3A>) {
+        let output: f32 = bevy::math::Vec3A::length(_self.into_inner()).into();
+        output
+    }
+    fn length_recip(_self: Val<bevy::math::Vec3A>) {
+        let output: f32 = bevy::math::Vec3A::length_recip(_self.into_inner()).into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::Vec3A>) {
+        let output: f32 = bevy::math::Vec3A::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn lerp(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>, s: f32) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::lerp(
+                _self.into_inner(),
+                rhs.into_inner(),
+                s,
+            )
+            .into();
+        output
+    }
+    fn max(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::max(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn max_element(_self: Val<bevy::math::Vec3A>) {
+        let output: f32 = bevy::math::Vec3A::max_element(_self.into_inner()).into();
+        output
+    }
+    fn midpoint(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::midpoint(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::min(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min_element(_self: Val<bevy::math::Vec3A>) {
+        let output: f32 = bevy::math::Vec3A::min_element(_self.into_inner()).into();
+        output
+    }
+    fn move_towards(_self: Ref<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>, d: f32) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::move_towards(
+                &_self,
+                rhs.into_inner(),
+                d,
+            )
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Vec3A>, rhs: Ref<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Mul<
+            &bevy::math::Vec3A,
+        >>::mul(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Mul<
+            bevy::math::Vec3A,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Vec3A>, rhs: f32) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Mul<
+            f32,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn mul_add(
+        _self: Val<bevy::math::Vec3A>,
+        a: Val<bevy::math::Vec3A>,
+        b: Val<bevy::math::Vec3A>,
+    ) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::mul_add(
+                _self.into_inner(),
+                a.into_inner(),
+                b.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(x: f32, y: f32, z: f32) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::new(x, y, z).into();
+        output
+    }
+    fn normalize(_self: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::normalize(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn normalize_or(_self: Val<bevy::math::Vec3A>, fallback: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::normalize_or(
+                _self.into_inner(),
+                fallback.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn normalize_or_zero(_self: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::normalize_or_zero(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn powf(_self: Val<bevy::math::Vec3A>, n: f32) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::powf(
+                _self.into_inner(),
+                n,
+            )
+            .into();
+        output
+    }
+    fn project_onto(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::project_onto(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn project_onto_normalized(
+        _self: Val<bevy::math::Vec3A>,
+        rhs: Val<bevy::math::Vec3A>,
+    ) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::project_onto_normalized(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn recip(_self: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::recip(_self.into_inner())
+            .into();
+        output
+    }
+    fn reflect(_self: Val<bevy::math::Vec3A>, normal: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::reflect(
+                _self.into_inner(),
+                normal.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn refract(_self: Val<bevy::math::Vec3A>, normal: Val<bevy::math::Vec3A>, eta: f32) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::refract(
+                _self.into_inner(),
+                normal.into_inner(),
+                eta,
+            )
+            .into();
+        output
+    }
+    fn reject_from(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::reject_from(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn reject_from_normalized(
+        _self: Val<bevy::math::Vec3A>,
+        rhs: Val<bevy::math::Vec3A>,
+    ) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::reject_from_normalized(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::Vec3A>, rhs: Ref<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Rem<
+            &bevy::math::Vec3A,
+        >>::rem(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Rem<
+            bevy::math::Vec3A,
+        >>::rem(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::Vec3A>, rhs: f32) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Rem<
+            f32,
+        >>::rem(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn rem_euclid(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::rem_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn round(_self: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::round(_self.into_inner())
+            .into();
+        output
+    }
+    fn select(
+        mask: Val<bevy::math::BVec3A>,
+        if_true: Val<bevy::math::Vec3A>,
+        if_false: Val<bevy::math::Vec3A>,
+    ) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::select(
+                mask.into_inner(),
+                if_true.into_inner(),
+                if_false.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn signum(_self: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::signum(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn splat(v: f32) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::splat(v).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::Vec3A>, rhs: Ref<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Sub<
+            &bevy::math::Vec3A,
+        >>::sub(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Sub<
+            bevy::math::Vec3A,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::Vec3A>, rhs: f32) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Sub<
+            f32,
+        >>::sub(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::Vec3A>) {
+        let output: [f32; 3] = bevy::math::Vec3A::to_array(&_self).into();
+        output
+    }
+    fn trunc(_self: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::trunc(_self.into_inner())
+            .into();
+        output
+    }
+    fn truncate(_self: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Vec3A::truncate(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn with_x(_self: Val<bevy::math::Vec3A>, x: f32) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::with_x(
+                _self.into_inner(),
+                x,
+            )
+            .into();
+        output
+    }
+    fn with_y(_self: Val<bevy::math::Vec3A>, y: f32) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::with_y(
+                _self.into_inner(),
+                y,
+            )
+            .into();
+        output
+    }
+    fn with_z(_self: Val<bevy::math::Vec3A>, z: f32) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::with_z(
+                _self.into_inner(),
+                z,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "vec_4")]
+impl bevy::math::Vec4 {
+    fn abs(_self: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::abs(_self.into_inner())
+            .into();
+        output
+    }
+    fn abs_diff_eq(
+        _self: Val<bevy::math::Vec4>,
+        rhs: Val<bevy::math::Vec4>,
+        max_abs_diff: f32,
+    ) {
+        let output: bool = bevy::math::Vec4::abs_diff_eq(
+                _self.into_inner(),
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::Vec4>, rhs: Ref<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Add<
+            &bevy::math::Vec4,
+        >>::add(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Add<
+            bevy::math::Vec4,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::Vec4>, rhs: f32) {
+        let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Add<
+            f32,
+        >>::add(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn as_dvec4(_self: Ref<bevy::math::Vec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::Vec4::as_dvec4(&_self).into();
+        output
+    }
+    fn as_i64vec4(_self: Ref<bevy::math::Vec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::Vec4::as_i64vec4(&_self)
+            .into();
+        output
+    }
+    fn as_ivec4(_self: Ref<bevy::math::Vec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::Vec4::as_ivec4(&_self).into();
+        output
+    }
+    fn as_u64vec4(_self: Ref<bevy::math::Vec4>) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::Vec4::as_u64vec4(&_self)
+            .into();
+        output
+    }
+    fn as_uvec4(_self: Ref<bevy::math::Vec4>) {
+        let output: Val<bevy::math::UVec4> = bevy::math::Vec4::as_uvec4(&_self).into();
+        output
+    }
+    fn ceil(_self: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::ceil(_self.into_inner())
+            .into();
+        output
+    }
+    fn clamp(
+        _self: Val<bevy::math::Vec4>,
+        min: Val<bevy::math::Vec4>,
+        max: Val<bevy::math::Vec4>,
+    ) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::clamp(
+                _self.into_inner(),
+                min.into_inner(),
+                max.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clamp_length(_self: Val<bevy::math::Vec4>, min: f32, max: f32) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::clamp_length(
+                _self.into_inner(),
+                min,
+                max,
+            )
+            .into();
+        output
+    }
+    fn clamp_length_max(_self: Val<bevy::math::Vec4>, max: f32) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::clamp_length_max(
+                _self.into_inner(),
+                max,
+            )
+            .into();
+        output
+    }
+    fn clamp_length_min(_self: Val<bevy::math::Vec4>, min: f32) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::clamp_length_min(
+                _self.into_inner(),
+                min,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn cmpeq(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::BVec4A> = bevy::math::Vec4::cmpeq(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpge(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::BVec4A> = bevy::math::Vec4::cmpge(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpgt(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::BVec4A> = bevy::math::Vec4::cmpgt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmple(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::BVec4A> = bevy::math::Vec4::cmple(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmplt(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::BVec4A> = bevy::math::Vec4::cmplt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpne(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::BVec4A> = bevy::math::Vec4::cmpne(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn copysign(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::copysign(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: f32 = bevy::math::Vec4::distance(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance_squared(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: f32 = bevy::math::Vec4::distance_squared(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::Vec4>, rhs: Ref<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Div<
+            &bevy::math::Vec4,
+        >>::div(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Div<
+            bevy::math::Vec4,
+        >>::div(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::Vec4>, rhs: f32) {
+        let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Div<
+            f32,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_euclid(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::div_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: f32 = bevy::math::Vec4::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn dot_into_vec(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::dot_into_vec(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn element_product(_self: Val<bevy::math::Vec4>) {
+        let output: f32 = bevy::math::Vec4::element_product(_self.into_inner()).into();
+        output
+    }
+    fn element_sum(_self: Val<bevy::math::Vec4>) {
+        let output: f32 = bevy::math::Vec4::element_sum(_self.into_inner()).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::Vec4>, rhs: Ref<bevy::math::Vec4>) {
+        let output: bool = <bevy::math::Vec4 as std::cmp::PartialEq<
+            bevy::math::Vec4,
+        >>::eq(&_self, &rhs)
+            .into();
+        output
+    }
+    fn exp(_self: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::exp(_self.into_inner())
+            .into();
+        output
+    }
+    fn floor(_self: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::floor(_self.into_inner())
+            .into();
+        output
+    }
+    fn fract(_self: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::fract(_self.into_inner())
+            .into();
+        output
+    }
+    fn fract_gl(_self: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::fract_gl(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_array(a: [f32; 4]) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::from_array(a).into();
+        output
+    }
+    fn is_finite(_self: Val<bevy::math::Vec4>) {
+        let output: bool = bevy::math::Vec4::is_finite(_self.into_inner()).into();
+        output
+    }
+    fn is_finite_mask(_self: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::BVec4A> = bevy::math::Vec4::is_finite_mask(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn is_nan(_self: Val<bevy::math::Vec4>) {
+        let output: bool = bevy::math::Vec4::is_nan(_self.into_inner()).into();
+        output
+    }
+    fn is_nan_mask(_self: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::BVec4A> = bevy::math::Vec4::is_nan_mask(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn is_negative_bitmask(_self: Val<bevy::math::Vec4>) {
+        let output: u32 = bevy::math::Vec4::is_negative_bitmask(_self.into_inner())
+            .into();
+        output
+    }
+    fn is_normalized(_self: Val<bevy::math::Vec4>) {
+        let output: bool = bevy::math::Vec4::is_normalized(_self.into_inner()).into();
+        output
+    }
+    fn length(_self: Val<bevy::math::Vec4>) {
+        let output: f32 = bevy::math::Vec4::length(_self.into_inner()).into();
+        output
+    }
+    fn length_recip(_self: Val<bevy::math::Vec4>) {
+        let output: f32 = bevy::math::Vec4::length_recip(_self.into_inner()).into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::Vec4>) {
+        let output: f32 = bevy::math::Vec4::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn lerp(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>, s: f32) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::lerp(
+                _self.into_inner(),
+                rhs.into_inner(),
+                s,
+            )
+            .into();
+        output
+    }
+    fn max(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::max(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn max_element(_self: Val<bevy::math::Vec4>) {
+        let output: f32 = bevy::math::Vec4::max_element(_self.into_inner()).into();
+        output
+    }
+    fn midpoint(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::midpoint(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::min(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min_element(_self: Val<bevy::math::Vec4>) {
+        let output: f32 = bevy::math::Vec4::min_element(_self.into_inner()).into();
+        output
+    }
+    fn move_towards(_self: Ref<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>, d: f32) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::move_towards(
+                &_self,
+                rhs.into_inner(),
+                d,
+            )
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Vec4>, rhs: Ref<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Mul<
+            &bevy::math::Vec4,
+        >>::mul(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Mul<
+            bevy::math::Vec4,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Vec4>, rhs: f32) {
+        let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Mul<
+            f32,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn mul_add(
+        _self: Val<bevy::math::Vec4>,
+        a: Val<bevy::math::Vec4>,
+        b: Val<bevy::math::Vec4>,
+    ) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::mul_add(
+                _self.into_inner(),
+                a.into_inner(),
+                b.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(x: f32, y: f32, z: f32, w: f32) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::new(x, y, z, w).into();
+        output
+    }
+    fn normalize(_self: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::normalize(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn normalize_or(_self: Val<bevy::math::Vec4>, fallback: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::normalize_or(
+                _self.into_inner(),
+                fallback.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn normalize_or_zero(_self: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::normalize_or_zero(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn powf(_self: Val<bevy::math::Vec4>, n: f32) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::powf(_self.into_inner(), n)
+            .into();
+        output
+    }
+    fn project_onto(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::project_onto(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn project_onto_normalized(
+        _self: Val<bevy::math::Vec4>,
+        rhs: Val<bevy::math::Vec4>,
+    ) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::project_onto_normalized(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn recip(_self: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::recip(_self.into_inner())
+            .into();
+        output
+    }
+    fn reflect(_self: Val<bevy::math::Vec4>, normal: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::reflect(
+                _self.into_inner(),
+                normal.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn refract(_self: Val<bevy::math::Vec4>, normal: Val<bevy::math::Vec4>, eta: f32) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::refract(
+                _self.into_inner(),
+                normal.into_inner(),
+                eta,
+            )
+            .into();
+        output
+    }
+    fn reject_from(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::reject_from(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn reject_from_normalized(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::reject_from_normalized(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::Vec4>, rhs: Ref<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Rem<
+            &bevy::math::Vec4,
+        >>::rem(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Rem<
+            bevy::math::Vec4,
+        >>::rem(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::Vec4>, rhs: f32) {
+        let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Rem<
+            f32,
+        >>::rem(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn rem_euclid(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::rem_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn round(_self: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::round(_self.into_inner())
+            .into();
+        output
+    }
+    fn select(
+        mask: Val<bevy::math::BVec4A>,
+        if_true: Val<bevy::math::Vec4>,
+        if_false: Val<bevy::math::Vec4>,
+    ) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::select(
+                mask.into_inner(),
+                if_true.into_inner(),
+                if_false.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn signum(_self: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::signum(_self.into_inner())
+            .into();
+        output
+    }
+    fn splat(v: f32) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::splat(v).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::Vec4>, rhs: Ref<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Sub<
+            &bevy::math::Vec4,
+        >>::sub(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Sub<
+            bevy::math::Vec4,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::Vec4>, rhs: f32) {
+        let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Sub<
+            f32,
+        >>::sub(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::Vec4>) {
+        let output: [f32; 4] = bevy::math::Vec4::to_array(&_self).into();
+        output
+    }
+    fn trunc(_self: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::trunc(_self.into_inner())
+            .into();
+        output
+    }
+    fn truncate(_self: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Vec4::truncate(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn with_w(_self: Val<bevy::math::Vec4>, w: f32) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::with_w(
+                _self.into_inner(),
+                w,
+            )
+            .into();
+        output
+    }
+    fn with_x(_self: Val<bevy::math::Vec4>, x: f32) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::with_x(
+                _self.into_inner(),
+                x,
+            )
+            .into();
+        output
+    }
+    fn with_y(_self: Val<bevy::math::Vec4>, y: f32) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::with_y(
+                _self.into_inner(),
+                y,
+            )
+            .into();
+        output
+    }
+    fn with_z(_self: Val<bevy::math::Vec4>, z: f32) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Vec4::with_z(
+                _self.into_inner(),
+                z,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "b_vec_2")]
+impl bevy::math::BVec2 {
+    fn all(_self: Val<bevy::math::BVec2>) {
+        let output: bool = bevy::math::BVec2::all(_self.into_inner()).into();
+        output
+    }
+    fn any(_self: Val<bevy::math::BVec2>) {
+        let output: bool = bevy::math::BVec2::any(_self.into_inner()).into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::BVec2>) {
+        let output: () = <bevy::math::BVec2 as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn bitmask(_self: Val<bevy::math::BVec2>) {
+        let output: u32 = bevy::math::BVec2::bitmask(_self.into_inner()).into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::BVec2>) {
+        let output: Val<bevy::math::BVec2> = <bevy::math::BVec2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::BVec2>, other: Ref<bevy::math::BVec2>) {
+        let output: bool = <bevy::math::BVec2 as std::cmp::PartialEq<
+            bevy::math::BVec2,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_array(a: [bool; 2]) {
+        let output: Val<bevy::math::BVec2> = bevy::math::BVec2::from_array(a).into();
+        output
+    }
+    fn new(x: bool, y: bool) {
+        let output: Val<bevy::math::BVec2> = bevy::math::BVec2::new(x, y).into();
+        output
+    }
+    fn set(mut _self: Mut<bevy::math::BVec2>, index: usize, value: bool) {
+        let output: () = bevy::math::BVec2::set(&mut _self, index, value).into();
+        output
+    }
+    fn splat(v: bool) {
+        let output: Val<bevy::math::BVec2> = bevy::math::BVec2::splat(v).into();
+        output
+    }
+    fn test(_self: Ref<bevy::math::BVec2>, index: usize) {
+        let output: bool = bevy::math::BVec2::test(&_self, index).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "b_vec_3")]
+impl bevy::math::BVec3 {
+    fn all(_self: Val<bevy::math::BVec3>) {
+        let output: bool = bevy::math::BVec3::all(_self.into_inner()).into();
+        output
+    }
+    fn any(_self: Val<bevy::math::BVec3>) {
+        let output: bool = bevy::math::BVec3::any(_self.into_inner()).into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::BVec3>) {
+        let output: () = <bevy::math::BVec3 as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn bitmask(_self: Val<bevy::math::BVec3>) {
+        let output: u32 = bevy::math::BVec3::bitmask(_self.into_inner()).into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::BVec3>) {
+        let output: Val<bevy::math::BVec3> = <bevy::math::BVec3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::BVec3>, other: Ref<bevy::math::BVec3>) {
+        let output: bool = <bevy::math::BVec3 as std::cmp::PartialEq<
+            bevy::math::BVec3,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_array(a: [bool; 3]) {
+        let output: Val<bevy::math::BVec3> = bevy::math::BVec3::from_array(a).into();
+        output
+    }
+    fn new(x: bool, y: bool, z: bool) {
+        let output: Val<bevy::math::BVec3> = bevy::math::BVec3::new(x, y, z).into();
+        output
+    }
+    fn set(mut _self: Mut<bevy::math::BVec3>, index: usize, value: bool) {
+        let output: () = bevy::math::BVec3::set(&mut _self, index, value).into();
+        output
+    }
+    fn splat(v: bool) {
+        let output: Val<bevy::math::BVec3> = bevy::math::BVec3::splat(v).into();
+        output
+    }
+    fn test(_self: Ref<bevy::math::BVec3>, index: usize) {
+        let output: bool = bevy::math::BVec3::test(&_self, index).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "b_vec_4")]
+impl bevy::math::BVec4 {
+    fn all(_self: Val<bevy::math::BVec4>) {
+        let output: bool = bevy::math::BVec4::all(_self.into_inner()).into();
+        output
+    }
+    fn any(_self: Val<bevy::math::BVec4>) {
+        let output: bool = bevy::math::BVec4::any(_self.into_inner()).into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::BVec4>) {
+        let output: () = <bevy::math::BVec4 as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn bitmask(_self: Val<bevy::math::BVec4>) {
+        let output: u32 = bevy::math::BVec4::bitmask(_self.into_inner()).into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::BVec4>) {
+        let output: Val<bevy::math::BVec4> = <bevy::math::BVec4 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::BVec4>, other: Ref<bevy::math::BVec4>) {
+        let output: bool = <bevy::math::BVec4 as std::cmp::PartialEq<
+            bevy::math::BVec4,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_array(a: [bool; 4]) {
+        let output: Val<bevy::math::BVec4> = bevy::math::BVec4::from_array(a).into();
+        output
+    }
+    fn new(x: bool, y: bool, z: bool, w: bool) {
+        let output: Val<bevy::math::BVec4> = bevy::math::BVec4::new(x, y, z, w).into();
+        output
+    }
+    fn set(mut _self: Mut<bevy::math::BVec4>, index: usize, value: bool) {
+        let output: () = bevy::math::BVec4::set(&mut _self, index, value).into();
+        output
+    }
+    fn splat(v: bool) {
+        let output: Val<bevy::math::BVec4> = bevy::math::BVec4::splat(v).into();
+        output
+    }
+    fn test(_self: Ref<bevy::math::BVec4>, index: usize) {
+        let output: bool = bevy::math::BVec4::test(&_self, index).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "d_vec_2")]
+impl bevy::math::DVec2 {
+    fn abs(_self: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::abs(_self.into_inner())
+            .into();
+        output
+    }
+    fn abs_diff_eq(
+        _self: Val<bevy::math::DVec2>,
+        rhs: Val<bevy::math::DVec2>,
+        max_abs_diff: f64,
+    ) {
+        let output: bool = bevy::math::DVec2::abs_diff_eq(
+                _self.into_inner(),
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::DVec2>, rhs: Ref<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Add<
+            &bevy::math::DVec2,
+        >>::add(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Add<
+            bevy::math::DVec2,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::DVec2>, rhs: f64) {
+        let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Add<
+            f64,
+        >>::add(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn angle_between(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: f64 = bevy::math::DVec2::angle_between(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn angle_to(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: f64 = bevy::math::DVec2::angle_to(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn as_i64vec2(_self: Ref<bevy::math::DVec2>) {
+        let output: Val<bevy::math::I64Vec2> = bevy::math::DVec2::as_i64vec2(&_self)
+            .into();
+        output
+    }
+    fn as_ivec2(_self: Ref<bevy::math::DVec2>) {
+        let output: Val<bevy::math::IVec2> = bevy::math::DVec2::as_ivec2(&_self).into();
+        output
+    }
+    fn as_u64vec2(_self: Ref<bevy::math::DVec2>) {
+        let output: Val<bevy::math::U64Vec2> = bevy::math::DVec2::as_u64vec2(&_self)
+            .into();
+        output
+    }
+    fn as_uvec2(_self: Ref<bevy::math::DVec2>) {
+        let output: Val<bevy::math::UVec2> = bevy::math::DVec2::as_uvec2(&_self).into();
+        output
+    }
+    fn as_vec2(_self: Ref<bevy::math::DVec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::DVec2::as_vec2(&_self).into();
+        output
+    }
+    fn ceil(_self: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::ceil(_self.into_inner())
+            .into();
+        output
+    }
+    fn clamp(
+        _self: Val<bevy::math::DVec2>,
+        min: Val<bevy::math::DVec2>,
+        max: Val<bevy::math::DVec2>,
+    ) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::clamp(
+                _self.into_inner(),
+                min.into_inner(),
+                max.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clamp_length(_self: Val<bevy::math::DVec2>, min: f64, max: f64) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::clamp_length(
+                _self.into_inner(),
+                min,
+                max,
+            )
+            .into();
+        output
+    }
+    fn clamp_length_max(_self: Val<bevy::math::DVec2>, max: f64) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::clamp_length_max(
+                _self.into_inner(),
+                max,
+            )
+            .into();
+        output
+    }
+    fn clamp_length_min(_self: Val<bevy::math::DVec2>, min: f64) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::clamp_length_min(
+                _self.into_inner(),
+                min,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn cmpeq(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::DVec2::cmpeq(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpge(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::DVec2::cmpge(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpgt(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::DVec2::cmpgt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmple(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::DVec2::cmple(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmplt(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::DVec2::cmplt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpne(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::DVec2::cmpne(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn copysign(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::copysign(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: f64 = bevy::math::DVec2::distance(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance_squared(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: f64 = bevy::math::DVec2::distance_squared(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::DVec2>, rhs: Ref<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Div<
+            &bevy::math::DVec2,
+        >>::div(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Div<
+            bevy::math::DVec2,
+        >>::div(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::DVec2>, rhs: f64) {
+        let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Div<
+            f64,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_euclid(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::div_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: f64 = bevy::math::DVec2::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn dot_into_vec(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::dot_into_vec(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn element_product(_self: Val<bevy::math::DVec2>) {
+        let output: f64 = bevy::math::DVec2::element_product(_self.into_inner()).into();
+        output
+    }
+    fn element_sum(_self: Val<bevy::math::DVec2>) {
+        let output: f64 = bevy::math::DVec2::element_sum(_self.into_inner()).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::DVec2>, other: Ref<bevy::math::DVec2>) {
+        let output: bool = <bevy::math::DVec2 as std::cmp::PartialEq<
+            bevy::math::DVec2,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn exp(_self: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::exp(_self.into_inner())
+            .into();
+        output
+    }
+    fn extend(_self: Val<bevy::math::DVec2>, z: f64) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec2::extend(
+                _self.into_inner(),
+                z,
+            )
+            .into();
+        output
+    }
+    fn floor(_self: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::floor(_self.into_inner())
+            .into();
+        output
+    }
+    fn fract(_self: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::fract(_self.into_inner())
+            .into();
+        output
+    }
+    fn fract_gl(_self: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::fract_gl(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_angle(angle: f64) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::from_angle(angle).into();
+        output
+    }
+    fn from_array(a: [f64; 2]) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::from_array(a).into();
+        output
+    }
+    fn is_finite(_self: Val<bevy::math::DVec2>) {
+        let output: bool = bevy::math::DVec2::is_finite(_self.into_inner()).into();
+        output
+    }
+    fn is_finite_mask(_self: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::DVec2::is_finite_mask(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn is_nan(_self: Val<bevy::math::DVec2>) {
+        let output: bool = bevy::math::DVec2::is_nan(_self.into_inner()).into();
+        output
+    }
+    fn is_nan_mask(_self: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::BVec2> = bevy::math::DVec2::is_nan_mask(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn is_negative_bitmask(_self: Val<bevy::math::DVec2>) {
+        let output: u32 = bevy::math::DVec2::is_negative_bitmask(_self.into_inner())
+            .into();
+        output
+    }
+    fn is_normalized(_self: Val<bevy::math::DVec2>) {
+        let output: bool = bevy::math::DVec2::is_normalized(_self.into_inner()).into();
+        output
+    }
+    fn length(_self: Val<bevy::math::DVec2>) {
+        let output: f64 = bevy::math::DVec2::length(_self.into_inner()).into();
+        output
+    }
+    fn length_recip(_self: Val<bevy::math::DVec2>) {
+        let output: f64 = bevy::math::DVec2::length_recip(_self.into_inner()).into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::DVec2>) {
+        let output: f64 = bevy::math::DVec2::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn lerp(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>, s: f64) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::lerp(
+                _self.into_inner(),
+                rhs.into_inner(),
+                s,
+            )
+            .into();
+        output
+    }
+    fn max(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::max(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn max_element(_self: Val<bevy::math::DVec2>) {
+        let output: f64 = bevy::math::DVec2::max_element(_self.into_inner()).into();
+        output
+    }
+    fn midpoint(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::midpoint(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::min(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min_element(_self: Val<bevy::math::DVec2>) {
+        let output: f64 = bevy::math::DVec2::min_element(_self.into_inner()).into();
+        output
+    }
+    fn move_towards(_self: Ref<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>, d: f64) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::move_towards(
+                &_self,
+                rhs.into_inner(),
+                d,
+            )
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DVec2>, rhs: Ref<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Mul<
+            &bevy::math::DVec2,
+        >>::mul(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Mul<
+            bevy::math::DVec2,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DVec2>, rhs: f64) {
+        let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Mul<
+            f64,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn mul_add(
+        _self: Val<bevy::math::DVec2>,
+        a: Val<bevy::math::DVec2>,
+        b: Val<bevy::math::DVec2>,
+    ) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::mul_add(
+                _self.into_inner(),
+                a.into_inner(),
+                b.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(x: f64, y: f64) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::new(x, y).into();
+        output
+    }
+    fn normalize(_self: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::normalize(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn normalize_or(_self: Val<bevy::math::DVec2>, fallback: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::normalize_or(
+                _self.into_inner(),
+                fallback.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn normalize_or_zero(_self: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::normalize_or_zero(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn perp(_self: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::perp(_self.into_inner())
+            .into();
+        output
+    }
+    fn perp_dot(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: f64 = bevy::math::DVec2::perp_dot(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn powf(_self: Val<bevy::math::DVec2>, n: f64) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::powf(
+                _self.into_inner(),
+                n,
+            )
+            .into();
+        output
+    }
+    fn project_onto(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::project_onto(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn project_onto_normalized(
+        _self: Val<bevy::math::DVec2>,
+        rhs: Val<bevy::math::DVec2>,
+    ) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::project_onto_normalized(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn recip(_self: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::recip(_self.into_inner())
+            .into();
+        output
+    }
+    fn reflect(_self: Val<bevy::math::DVec2>, normal: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::reflect(
+                _self.into_inner(),
+                normal.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn refract(_self: Val<bevy::math::DVec2>, normal: Val<bevy::math::DVec2>, eta: f64) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::refract(
+                _self.into_inner(),
+                normal.into_inner(),
+                eta,
+            )
+            .into();
+        output
+    }
+    fn reject_from(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::reject_from(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn reject_from_normalized(
+        _self: Val<bevy::math::DVec2>,
+        rhs: Val<bevy::math::DVec2>,
+    ) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::reject_from_normalized(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::DVec2>, rhs: Ref<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Rem<
+            &bevy::math::DVec2,
+        >>::rem(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Rem<
+            bevy::math::DVec2,
+        >>::rem(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::DVec2>, rhs: f64) {
+        let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Rem<
+            f64,
+        >>::rem(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn rem_euclid(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::rem_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rotate(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::rotate(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rotate_towards(
+        _self: Ref<bevy::math::DVec2>,
+        rhs: Val<bevy::math::DVec2>,
+        max_angle: f64,
+    ) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::rotate_towards(
+                &_self,
+                rhs.into_inner(),
+                max_angle,
+            )
+            .into();
+        output
+    }
+    fn round(_self: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::round(_self.into_inner())
+            .into();
+        output
+    }
+    fn select(
+        mask: Val<bevy::math::BVec2>,
+        if_true: Val<bevy::math::DVec2>,
+        if_false: Val<bevy::math::DVec2>,
+    ) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::select(
+                mask.into_inner(),
+                if_true.into_inner(),
+                if_false.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn signum(_self: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::signum(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn splat(v: f64) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::splat(v).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::DVec2>, rhs: Ref<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Sub<
+            &bevy::math::DVec2,
+        >>::sub(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Sub<
+            bevy::math::DVec2,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::DVec2>, rhs: f64) {
+        let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Sub<
+            f64,
+        >>::sub(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn to_angle(_self: Val<bevy::math::DVec2>) {
+        let output: f64 = bevy::math::DVec2::to_angle(_self.into_inner()).into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::DVec2>) {
+        let output: [f64; 2] = bevy::math::DVec2::to_array(&_self).into();
+        output
+    }
+    fn trunc(_self: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::trunc(_self.into_inner())
+            .into();
+        output
+    }
+    fn with_x(_self: Val<bevy::math::DVec2>, x: f64) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::with_x(
+                _self.into_inner(),
+                x,
+            )
+            .into();
+        output
+    }
+    fn with_y(_self: Val<bevy::math::DVec2>, y: f64) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec2::with_y(
+                _self.into_inner(),
+                y,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "d_vec_3")]
+impl bevy::math::DVec3 {
+    fn abs(_self: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::abs(_self.into_inner())
+            .into();
+        output
+    }
+    fn abs_diff_eq(
+        _self: Val<bevy::math::DVec3>,
+        rhs: Val<bevy::math::DVec3>,
+        max_abs_diff: f64,
+    ) {
+        let output: bool = bevy::math::DVec3::abs_diff_eq(
+                _self.into_inner(),
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::DVec3>, rhs: Ref<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Add<
+            &bevy::math::DVec3,
+        >>::add(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Add<
+            bevy::math::DVec3,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::DVec3>, rhs: f64) {
+        let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Add<
+            f64,
+        >>::add(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn angle_between(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: f64 = bevy::math::DVec3::angle_between(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn any_orthogonal_vector(_self: Ref<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::any_orthogonal_vector(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn any_orthonormal_vector(_self: Ref<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::any_orthonormal_vector(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn as_i64vec3(_self: Ref<bevy::math::DVec3>) {
+        let output: Val<bevy::math::I64Vec3> = bevy::math::DVec3::as_i64vec3(&_self)
+            .into();
+        output
+    }
+    fn as_ivec3(_self: Ref<bevy::math::DVec3>) {
+        let output: Val<bevy::math::IVec3> = bevy::math::DVec3::as_ivec3(&_self).into();
+        output
+    }
+    fn as_u64vec3(_self: Ref<bevy::math::DVec3>) {
+        let output: Val<bevy::math::U64Vec3> = bevy::math::DVec3::as_u64vec3(&_self)
+            .into();
+        output
+    }
+    fn as_uvec3(_self: Ref<bevy::math::DVec3>) {
+        let output: Val<bevy::math::UVec3> = bevy::math::DVec3::as_uvec3(&_self).into();
+        output
+    }
+    fn as_vec3(_self: Ref<bevy::math::DVec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::DVec3::as_vec3(&_self).into();
+        output
+    }
+    fn as_vec3a(_self: Ref<bevy::math::DVec3>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::DVec3::as_vec3a(&_self).into();
+        output
+    }
+    fn ceil(_self: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::ceil(_self.into_inner())
+            .into();
+        output
+    }
+    fn clamp(
+        _self: Val<bevy::math::DVec3>,
+        min: Val<bevy::math::DVec3>,
+        max: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::clamp(
+                _self.into_inner(),
+                min.into_inner(),
+                max.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clamp_length(_self: Val<bevy::math::DVec3>, min: f64, max: f64) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::clamp_length(
+                _self.into_inner(),
+                min,
+                max,
+            )
+            .into();
+        output
+    }
+    fn clamp_length_max(_self: Val<bevy::math::DVec3>, max: f64) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::clamp_length_max(
+                _self.into_inner(),
+                max,
+            )
+            .into();
+        output
+    }
+    fn clamp_length_min(_self: Val<bevy::math::DVec3>, min: f64) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::clamp_length_min(
+                _self.into_inner(),
+                min,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn cmpeq(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::DVec3::cmpeq(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpge(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::DVec3::cmpge(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpgt(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::DVec3::cmpgt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmple(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::DVec3::cmple(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmplt(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::DVec3::cmplt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpne(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::DVec3::cmpne(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn copysign(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::copysign(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cross(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::cross(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: f64 = bevy::math::DVec3::distance(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance_squared(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: f64 = bevy::math::DVec3::distance_squared(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::DVec3>, rhs: Ref<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Div<
+            &bevy::math::DVec3,
+        >>::div(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Div<
+            bevy::math::DVec3,
+        >>::div(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::DVec3>, rhs: f64) {
+        let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Div<
+            f64,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_euclid(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::div_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: f64 = bevy::math::DVec3::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn dot_into_vec(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::dot_into_vec(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn element_product(_self: Val<bevy::math::DVec3>) {
+        let output: f64 = bevy::math::DVec3::element_product(_self.into_inner()).into();
+        output
+    }
+    fn element_sum(_self: Val<bevy::math::DVec3>) {
+        let output: f64 = bevy::math::DVec3::element_sum(_self.into_inner()).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::DVec3>, other: Ref<bevy::math::DVec3>) {
+        let output: bool = <bevy::math::DVec3 as std::cmp::PartialEq<
+            bevy::math::DVec3,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn exp(_self: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::exp(_self.into_inner())
+            .into();
+        output
+    }
+    fn extend(_self: Val<bevy::math::DVec3>, w: f64) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec3::extend(
+                _self.into_inner(),
+                w,
+            )
+            .into();
+        output
+    }
+    fn floor(_self: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::floor(_self.into_inner())
+            .into();
+        output
+    }
+    fn fract(_self: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::fract(_self.into_inner())
+            .into();
+        output
+    }
+    fn fract_gl(_self: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::fract_gl(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_array(a: [f64; 3]) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::from_array(a).into();
+        output
+    }
+    fn is_finite(_self: Val<bevy::math::DVec3>) {
+        let output: bool = bevy::math::DVec3::is_finite(_self.into_inner()).into();
+        output
+    }
+    fn is_finite_mask(_self: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::DVec3::is_finite_mask(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn is_nan(_self: Val<bevy::math::DVec3>) {
+        let output: bool = bevy::math::DVec3::is_nan(_self.into_inner()).into();
+        output
+    }
+    fn is_nan_mask(_self: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::BVec3> = bevy::math::DVec3::is_nan_mask(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn is_negative_bitmask(_self: Val<bevy::math::DVec3>) {
+        let output: u32 = bevy::math::DVec3::is_negative_bitmask(_self.into_inner())
+            .into();
+        output
+    }
+    fn is_normalized(_self: Val<bevy::math::DVec3>) {
+        let output: bool = bevy::math::DVec3::is_normalized(_self.into_inner()).into();
+        output
+    }
+    fn length(_self: Val<bevy::math::DVec3>) {
+        let output: f64 = bevy::math::DVec3::length(_self.into_inner()).into();
+        output
+    }
+    fn length_recip(_self: Val<bevy::math::DVec3>) {
+        let output: f64 = bevy::math::DVec3::length_recip(_self.into_inner()).into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::DVec3>) {
+        let output: f64 = bevy::math::DVec3::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn lerp(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>, s: f64) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::lerp(
+                _self.into_inner(),
+                rhs.into_inner(),
+                s,
+            )
+            .into();
+        output
+    }
+    fn max(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::max(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn max_element(_self: Val<bevy::math::DVec3>) {
+        let output: f64 = bevy::math::DVec3::max_element(_self.into_inner()).into();
+        output
+    }
+    fn midpoint(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::midpoint(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::min(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min_element(_self: Val<bevy::math::DVec3>) {
+        let output: f64 = bevy::math::DVec3::min_element(_self.into_inner()).into();
+        output
+    }
+    fn move_towards(_self: Ref<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>, d: f64) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::move_towards(
+                &_self,
+                rhs.into_inner(),
+                d,
+            )
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DVec3>, rhs: Ref<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Mul<
+            &bevy::math::DVec3,
+        >>::mul(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Mul<
+            bevy::math::DVec3,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DVec3>, rhs: f64) {
+        let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Mul<
+            f64,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn mul_add(
+        _self: Val<bevy::math::DVec3>,
+        a: Val<bevy::math::DVec3>,
+        b: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::mul_add(
+                _self.into_inner(),
+                a.into_inner(),
+                b.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(x: f64, y: f64, z: f64) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::new(x, y, z).into();
+        output
+    }
+    fn normalize(_self: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::normalize(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn normalize_or(_self: Val<bevy::math::DVec3>, fallback: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::normalize_or(
+                _self.into_inner(),
+                fallback.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn normalize_or_zero(_self: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::normalize_or_zero(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn powf(_self: Val<bevy::math::DVec3>, n: f64) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::powf(
+                _self.into_inner(),
+                n,
+            )
+            .into();
+        output
+    }
+    fn project_onto(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::project_onto(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn project_onto_normalized(
+        _self: Val<bevy::math::DVec3>,
+        rhs: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::project_onto_normalized(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn recip(_self: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::recip(_self.into_inner())
+            .into();
+        output
+    }
+    fn reflect(_self: Val<bevy::math::DVec3>, normal: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::reflect(
+                _self.into_inner(),
+                normal.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn refract(_self: Val<bevy::math::DVec3>, normal: Val<bevy::math::DVec3>, eta: f64) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::refract(
+                _self.into_inner(),
+                normal.into_inner(),
+                eta,
+            )
+            .into();
+        output
+    }
+    fn reject_from(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::reject_from(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn reject_from_normalized(
+        _self: Val<bevy::math::DVec3>,
+        rhs: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::reject_from_normalized(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::DVec3>, rhs: Ref<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Rem<
+            &bevy::math::DVec3,
+        >>::rem(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Rem<
+            bevy::math::DVec3,
+        >>::rem(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::DVec3>, rhs: f64) {
+        let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Rem<
+            f64,
+        >>::rem(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn rem_euclid(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::rem_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn round(_self: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::round(_self.into_inner())
+            .into();
+        output
+    }
+    fn select(
+        mask: Val<bevy::math::BVec3>,
+        if_true: Val<bevy::math::DVec3>,
+        if_false: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::select(
+                mask.into_inner(),
+                if_true.into_inner(),
+                if_false.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn signum(_self: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::signum(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn splat(v: f64) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::splat(v).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::DVec3>, rhs: Ref<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Sub<
+            &bevy::math::DVec3,
+        >>::sub(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Sub<
+            bevy::math::DVec3,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::DVec3>, rhs: f64) {
+        let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Sub<
+            f64,
+        >>::sub(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::DVec3>) {
+        let output: [f64; 3] = bevy::math::DVec3::to_array(&_self).into();
+        output
+    }
+    fn trunc(_self: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::trunc(_self.into_inner())
+            .into();
+        output
+    }
+    fn truncate(_self: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DVec3::truncate(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn with_x(_self: Val<bevy::math::DVec3>, x: f64) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::with_x(
+                _self.into_inner(),
+                x,
+            )
+            .into();
+        output
+    }
+    fn with_y(_self: Val<bevy::math::DVec3>, y: f64) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::with_y(
+                _self.into_inner(),
+                y,
+            )
+            .into();
+        output
+    }
+    fn with_z(_self: Val<bevy::math::DVec3>, z: f64) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec3::with_z(
+                _self.into_inner(),
+                z,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "d_vec_4")]
+impl bevy::math::DVec4 {
+    fn abs(_self: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::abs(_self.into_inner())
+            .into();
+        output
+    }
+    fn abs_diff_eq(
+        _self: Val<bevy::math::DVec4>,
+        rhs: Val<bevy::math::DVec4>,
+        max_abs_diff: f64,
+    ) {
+        let output: bool = bevy::math::DVec4::abs_diff_eq(
+                _self.into_inner(),
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::DVec4>, rhs: Ref<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Add<
+            &bevy::math::DVec4,
+        >>::add(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Add<
+            bevy::math::DVec4,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::DVec4>, rhs: f64) {
+        let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Add<
+            f64,
+        >>::add(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn as_i64vec4(_self: Ref<bevy::math::DVec4>) {
+        let output: Val<bevy::math::I64Vec4> = bevy::math::DVec4::as_i64vec4(&_self)
+            .into();
+        output
+    }
+    fn as_ivec4(_self: Ref<bevy::math::DVec4>) {
+        let output: Val<bevy::math::IVec4> = bevy::math::DVec4::as_ivec4(&_self).into();
+        output
+    }
+    fn as_u64vec4(_self: Ref<bevy::math::DVec4>) {
+        let output: Val<bevy::math::U64Vec4> = bevy::math::DVec4::as_u64vec4(&_self)
+            .into();
+        output
+    }
+    fn as_uvec4(_self: Ref<bevy::math::DVec4>) {
+        let output: Val<bevy::math::UVec4> = bevy::math::DVec4::as_uvec4(&_self).into();
+        output
+    }
+    fn as_vec4(_self: Ref<bevy::math::DVec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::DVec4::as_vec4(&_self).into();
+        output
+    }
+    fn ceil(_self: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::ceil(_self.into_inner())
+            .into();
+        output
+    }
+    fn clamp(
+        _self: Val<bevy::math::DVec4>,
+        min: Val<bevy::math::DVec4>,
+        max: Val<bevy::math::DVec4>,
+    ) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::clamp(
+                _self.into_inner(),
+                min.into_inner(),
+                max.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clamp_length(_self: Val<bevy::math::DVec4>, min: f64, max: f64) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::clamp_length(
+                _self.into_inner(),
+                min,
+                max,
+            )
+            .into();
+        output
+    }
+    fn clamp_length_max(_self: Val<bevy::math::DVec4>, max: f64) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::clamp_length_max(
+                _self.into_inner(),
+                max,
+            )
+            .into();
+        output
+    }
+    fn clamp_length_min(_self: Val<bevy::math::DVec4>, min: f64) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::clamp_length_min(
+                _self.into_inner(),
+                min,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn cmpeq(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::DVec4::cmpeq(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpge(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::DVec4::cmpge(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpgt(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::DVec4::cmpgt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmple(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::DVec4::cmple(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmplt(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::DVec4::cmplt(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn cmpne(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::DVec4::cmpne(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn copysign(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::copysign(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: f64 = bevy::math::DVec4::distance(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn distance_squared(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: f64 = bevy::math::DVec4::distance_squared(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::DVec4>, rhs: Ref<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Div<
+            &bevy::math::DVec4,
+        >>::div(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Div<
+            bevy::math::DVec4,
+        >>::div(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::DVec4>, rhs: f64) {
+        let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Div<
+            f64,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_euclid(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::div_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: f64 = bevy::math::DVec4::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn dot_into_vec(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::dot_into_vec(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn element_product(_self: Val<bevy::math::DVec4>) {
+        let output: f64 = bevy::math::DVec4::element_product(_self.into_inner()).into();
+        output
+    }
+    fn element_sum(_self: Val<bevy::math::DVec4>) {
+        let output: f64 = bevy::math::DVec4::element_sum(_self.into_inner()).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::DVec4>, other: Ref<bevy::math::DVec4>) {
+        let output: bool = <bevy::math::DVec4 as std::cmp::PartialEq<
+            bevy::math::DVec4,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn exp(_self: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::exp(_self.into_inner())
+            .into();
+        output
+    }
+    fn floor(_self: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::floor(_self.into_inner())
+            .into();
+        output
+    }
+    fn fract(_self: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::fract(_self.into_inner())
+            .into();
+        output
+    }
+    fn fract_gl(_self: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::fract_gl(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_array(a: [f64; 4]) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::from_array(a).into();
+        output
+    }
+    fn is_finite(_self: Val<bevy::math::DVec4>) {
+        let output: bool = bevy::math::DVec4::is_finite(_self.into_inner()).into();
+        output
+    }
+    fn is_finite_mask(_self: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::DVec4::is_finite_mask(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn is_nan(_self: Val<bevy::math::DVec4>) {
+        let output: bool = bevy::math::DVec4::is_nan(_self.into_inner()).into();
+        output
+    }
+    fn is_nan_mask(_self: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::BVec4> = bevy::math::DVec4::is_nan_mask(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn is_negative_bitmask(_self: Val<bevy::math::DVec4>) {
+        let output: u32 = bevy::math::DVec4::is_negative_bitmask(_self.into_inner())
+            .into();
+        output
+    }
+    fn is_normalized(_self: Val<bevy::math::DVec4>) {
+        let output: bool = bevy::math::DVec4::is_normalized(_self.into_inner()).into();
+        output
+    }
+    fn length(_self: Val<bevy::math::DVec4>) {
+        let output: f64 = bevy::math::DVec4::length(_self.into_inner()).into();
+        output
+    }
+    fn length_recip(_self: Val<bevy::math::DVec4>) {
+        let output: f64 = bevy::math::DVec4::length_recip(_self.into_inner()).into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::DVec4>) {
+        let output: f64 = bevy::math::DVec4::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn lerp(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>, s: f64) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::lerp(
+                _self.into_inner(),
+                rhs.into_inner(),
+                s,
+            )
+            .into();
+        output
+    }
+    fn max(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::max(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn max_element(_self: Val<bevy::math::DVec4>) {
+        let output: f64 = bevy::math::DVec4::max_element(_self.into_inner()).into();
+        output
+    }
+    fn midpoint(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::midpoint(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::min(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn min_element(_self: Val<bevy::math::DVec4>) {
+        let output: f64 = bevy::math::DVec4::min_element(_self.into_inner()).into();
+        output
+    }
+    fn move_towards(_self: Ref<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>, d: f64) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::move_towards(
+                &_self,
+                rhs.into_inner(),
+                d,
+            )
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DVec4>, rhs: Ref<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Mul<
+            &bevy::math::DVec4,
+        >>::mul(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Mul<
+            bevy::math::DVec4,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DVec4>, rhs: f64) {
+        let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Mul<
+            f64,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn mul_add(
+        _self: Val<bevy::math::DVec4>,
+        a: Val<bevy::math::DVec4>,
+        b: Val<bevy::math::DVec4>,
+    ) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::mul_add(
+                _self.into_inner(),
+                a.into_inner(),
+                b.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn new(x: f64, y: f64, z: f64, w: f64) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::new(x, y, z, w).into();
+        output
+    }
+    fn normalize(_self: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::normalize(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn normalize_or(_self: Val<bevy::math::DVec4>, fallback: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::normalize_or(
+                _self.into_inner(),
+                fallback.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn normalize_or_zero(_self: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::normalize_or_zero(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn powf(_self: Val<bevy::math::DVec4>, n: f64) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::powf(
+                _self.into_inner(),
+                n,
+            )
+            .into();
+        output
+    }
+    fn project_onto(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::project_onto(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn project_onto_normalized(
+        _self: Val<bevy::math::DVec4>,
+        rhs: Val<bevy::math::DVec4>,
+    ) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::project_onto_normalized(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn recip(_self: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::recip(_self.into_inner())
+            .into();
+        output
+    }
+    fn reflect(_self: Val<bevy::math::DVec4>, normal: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::reflect(
+                _self.into_inner(),
+                normal.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn refract(_self: Val<bevy::math::DVec4>, normal: Val<bevy::math::DVec4>, eta: f64) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::refract(
+                _self.into_inner(),
+                normal.into_inner(),
+                eta,
+            )
+            .into();
+        output
+    }
+    fn reject_from(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::reject_from(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn reject_from_normalized(
+        _self: Val<bevy::math::DVec4>,
+        rhs: Val<bevy::math::DVec4>,
+    ) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::reject_from_normalized(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::DVec4>, rhs: Ref<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Rem<
+            &bevy::math::DVec4,
+        >>::rem(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Rem<
+            bevy::math::DVec4,
+        >>::rem(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn rem(_self: Val<bevy::math::DVec4>, rhs: f64) {
+        let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Rem<
+            f64,
+        >>::rem(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn rem_euclid(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::rem_euclid(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn round(_self: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::round(_self.into_inner())
+            .into();
+        output
+    }
+    fn select(
+        mask: Val<bevy::math::BVec4>,
+        if_true: Val<bevy::math::DVec4>,
+        if_false: Val<bevy::math::DVec4>,
+    ) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::select(
+                mask.into_inner(),
+                if_true.into_inner(),
+                if_false.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn signum(_self: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::signum(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn splat(v: f64) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::splat(v).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::DVec4>, rhs: Ref<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Sub<
+            &bevy::math::DVec4,
+        >>::sub(_self.into_inner(), &rhs)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Sub<
+            bevy::math::DVec4,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::DVec4>, rhs: f64) {
+        let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Sub<
+            f64,
+        >>::sub(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::DVec4>) {
+        let output: [f64; 4] = bevy::math::DVec4::to_array(&_self).into();
+        output
+    }
+    fn trunc(_self: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::trunc(_self.into_inner())
+            .into();
+        output
+    }
+    fn truncate(_self: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DVec4::truncate(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn with_w(_self: Val<bevy::math::DVec4>, w: f64) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::with_w(
+                _self.into_inner(),
+                w,
+            )
+            .into();
+        output
+    }
+    fn with_x(_self: Val<bevy::math::DVec4>, x: f64) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::with_x(
+                _self.into_inner(),
+                x,
+            )
+            .into();
+        output
+    }
+    fn with_y(_self: Val<bevy::math::DVec4>, y: f64) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::with_y(
+                _self.into_inner(),
+                y,
+            )
+            .into();
+        output
+    }
+    fn with_z(_self: Val<bevy::math::DVec4>, z: f64) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DVec4::with_z(
+                _self.into_inner(),
+                z,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "mat_2")]
+impl bevy::math::Mat2 {
+    fn abs(_self: Ref<bevy::math::Mat2>) {
+        let output: Val<bevy::math::Mat2> = bevy::math::Mat2::abs(&_self).into();
+        output
+    }
+    fn abs_diff_eq(
+        _self: Ref<bevy::math::Mat2>,
+        rhs: Val<bevy::math::Mat2>,
+        max_abs_diff: f32,
+    ) {
+        let output: bool = bevy::math::Mat2::abs_diff_eq(
+                &_self,
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::Mat2>, rhs: Val<bevy::math::Mat2>) {
+        let output: Val<bevy::math::Mat2> = <bevy::math::Mat2 as std::ops::Add<
+            bevy::math::Mat2,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add_mat2(_self: Ref<bevy::math::Mat2>, rhs: Ref<bevy::math::Mat2>) {
+        let output: Val<bevy::math::Mat2> = bevy::math::Mat2::add_mat2(&_self, &rhs)
+            .into();
+        output
+    }
+    fn as_dmat2(_self: Ref<bevy::math::Mat2>) {
+        let output: Val<bevy::math::DMat2> = bevy::math::Mat2::as_dmat2(&_self).into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::Mat2>) {
+        let output: Val<bevy::math::Mat2> = <bevy::math::Mat2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn col(_self: Ref<bevy::math::Mat2>, index: usize) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Mat2::col(&_self, index).into();
+        output
+    }
+    fn determinant(_self: Ref<bevy::math::Mat2>) {
+        let output: f32 = bevy::math::Mat2::determinant(&_self).into();
+        output
+    }
+    fn div(_self: Val<bevy::math::Mat2>, rhs: f32) {
+        let output: Val<bevy::math::Mat2> = <bevy::math::Mat2 as std::ops::Div<
+            f32,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_scalar(_self: Ref<bevy::math::Mat2>, rhs: f32) {
+        let output: Val<bevy::math::Mat2> = bevy::math::Mat2::div_scalar(&_self, rhs)
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::Mat2>, rhs: Ref<bevy::math::Mat2>) {
+        let output: bool = <bevy::math::Mat2 as std::cmp::PartialEq<
+            bevy::math::Mat2,
+        >>::eq(&_self, &rhs)
+            .into();
+        output
+    }
+    fn from_angle(angle: f32) {
+        let output: Val<bevy::math::Mat2> = bevy::math::Mat2::from_angle(angle).into();
+        output
+    }
+    fn from_cols(x_axis: Val<bevy::math::Vec2>, y_axis: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Mat2> = bevy::math::Mat2::from_cols(
+                x_axis.into_inner(),
+                y_axis.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_diagonal(diagonal: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Mat2> = bevy::math::Mat2::from_diagonal(
+                diagonal.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_mat3(m: Val<bevy::math::Mat3>) {
+        let output: Val<bevy::math::Mat2> = bevy::math::Mat2::from_mat3(m.into_inner())
+            .into();
+        output
+    }
+    fn from_mat3_minor(m: Val<bevy::math::Mat3>, i: usize, j: usize) {
+        let output: Val<bevy::math::Mat2> = bevy::math::Mat2::from_mat3_minor(
+                m.into_inner(),
+                i,
+                j,
+            )
+            .into();
+        output
+    }
+    fn from_mat3a(m: Val<bevy::math::Mat3A>) {
+        let output: Val<bevy::math::Mat2> = bevy::math::Mat2::from_mat3a(m.into_inner())
+            .into();
+        output
+    }
+    fn from_mat3a_minor(m: Val<bevy::math::Mat3A>, i: usize, j: usize) {
+        let output: Val<bevy::math::Mat2> = bevy::math::Mat2::from_mat3a_minor(
+                m.into_inner(),
+                i,
+                j,
+            )
+            .into();
+        output
+    }
+    fn from_scale_angle(scale: Val<bevy::math::Vec2>, angle: f32) {
+        let output: Val<bevy::math::Mat2> = bevy::math::Mat2::from_scale_angle(
+                scale.into_inner(),
+                angle,
+            )
+            .into();
+        output
+    }
+    fn inverse(_self: Ref<bevy::math::Mat2>) {
+        let output: Val<bevy::math::Mat2> = bevy::math::Mat2::inverse(&_self).into();
+        output
+    }
+    fn is_finite(_self: Ref<bevy::math::Mat2>) {
+        let output: bool = bevy::math::Mat2::is_finite(&_self).into();
+        output
+    }
+    fn is_nan(_self: Ref<bevy::math::Mat2>) {
+        let output: bool = bevy::math::Mat2::is_nan(&_self).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Mat2>, rhs: Val<bevy::math::Mat2>) {
+        let output: Val<bevy::math::Mat2> = <bevy::math::Mat2 as std::ops::Mul<
+            bevy::math::Mat2,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Mat2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = <bevy::math::Mat2 as std::ops::Mul<
+            bevy::math::Vec2,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Mat2>, rhs: f32) {
+        let output: Val<bevy::math::Mat2> = <bevy::math::Mat2 as std::ops::Mul<
+            f32,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn mul_mat2(_self: Ref<bevy::math::Mat2>, rhs: Ref<bevy::math::Mat2>) {
+        let output: Val<bevy::math::Mat2> = bevy::math::Mat2::mul_mat2(&_self, &rhs)
+            .into();
+        output
+    }
+    fn mul_scalar(_self: Ref<bevy::math::Mat2>, rhs: f32) {
+        let output: Val<bevy::math::Mat2> = bevy::math::Mat2::mul_scalar(&_self, rhs)
+            .into();
+        output
+    }
+    fn mul_vec2(_self: Ref<bevy::math::Mat2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Mat2::mul_vec2(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::Mat2>) {
+        let output: Val<bevy::math::Mat2> = <bevy::math::Mat2 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn row(_self: Ref<bevy::math::Mat2>, index: usize) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Mat2::row(&_self, index).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::Mat2>, rhs: Val<bevy::math::Mat2>) {
+        let output: Val<bevy::math::Mat2> = <bevy::math::Mat2 as std::ops::Sub<
+            bevy::math::Mat2,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub_mat2(_self: Ref<bevy::math::Mat2>, rhs: Ref<bevy::math::Mat2>) {
+        let output: Val<bevy::math::Mat2> = bevy::math::Mat2::sub_mat2(&_self, &rhs)
+            .into();
+        output
+    }
+    fn to_cols_array(_self: Ref<bevy::math::Mat2>) {
+        let output: [f32; 4] = bevy::math::Mat2::to_cols_array(&_self).into();
+        output
+    }
+    fn to_cols_array_2d(_self: Ref<bevy::math::Mat2>) {
+        let output: [[f32; 2]; 2] = bevy::math::Mat2::to_cols_array_2d(&_self).into();
+        output
+    }
+    fn transpose(_self: Ref<bevy::math::Mat2>) {
+        let output: Val<bevy::math::Mat2> = bevy::math::Mat2::transpose(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "mat_3")]
+impl bevy::math::Mat3 {
+    fn abs(_self: Ref<bevy::math::Mat3>) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::abs(&_self).into();
+        output
+    }
+    fn abs_diff_eq(
+        _self: Ref<bevy::math::Mat3>,
+        rhs: Val<bevy::math::Mat3>,
+        max_abs_diff: f32,
+    ) {
+        let output: bool = bevy::math::Mat3::abs_diff_eq(
+                &_self,
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::Mat3>, rhs: Val<bevy::math::Mat3>) {
+        let output: Val<bevy::math::Mat3> = <bevy::math::Mat3 as std::ops::Add<
+            bevy::math::Mat3,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add_mat3(_self: Ref<bevy::math::Mat3>, rhs: Ref<bevy::math::Mat3>) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::add_mat3(&_self, &rhs)
+            .into();
+        output
+    }
+    fn as_dmat3(_self: Ref<bevy::math::Mat3>) {
+        let output: Val<bevy::math::DMat3> = bevy::math::Mat3::as_dmat3(&_self).into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::Mat3>) {
+        let output: Val<bevy::math::Mat3> = <bevy::math::Mat3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn col(_self: Ref<bevy::math::Mat3>, index: usize) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Mat3::col(&_self, index).into();
+        output
+    }
+    fn determinant(_self: Ref<bevy::math::Mat3>) {
+        let output: f32 = bevy::math::Mat3::determinant(&_self).into();
+        output
+    }
+    fn div(_self: Val<bevy::math::Mat3>, rhs: f32) {
+        let output: Val<bevy::math::Mat3> = <bevy::math::Mat3 as std::ops::Div<
+            f32,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_scalar(_self: Ref<bevy::math::Mat3>, rhs: f32) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::div_scalar(&_self, rhs)
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::Mat3>, rhs: Ref<bevy::math::Mat3>) {
+        let output: bool = <bevy::math::Mat3 as std::cmp::PartialEq<
+            bevy::math::Mat3,
+        >>::eq(&_self, &rhs)
+            .into();
+        output
+    }
+    fn from_angle(angle: f32) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_angle(angle).into();
+        output
+    }
+    fn from_axis_angle(axis: Val<bevy::math::Vec3>, angle: f32) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_axis_angle(
+                axis.into_inner(),
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_cols(
+        x_axis: Val<bevy::math::Vec3>,
+        y_axis: Val<bevy::math::Vec3>,
+        z_axis: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_cols(
+                x_axis.into_inner(),
+                y_axis.into_inner(),
+                z_axis.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_diagonal(diagonal: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_diagonal(
+                diagonal.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_euler(order: Val<bevy::math::EulerRot>, a: f32, b: f32, c: f32) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_euler(
+                order.into_inner(),
+                a,
+                b,
+                c,
+            )
+            .into();
+        output
+    }
+    fn from_mat2(m: Val<bevy::math::Mat2>) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_mat2(m.into_inner())
+            .into();
+        output
+    }
+    fn from_mat4(m: Val<bevy::math::Mat4>) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_mat4(m.into_inner())
+            .into();
+        output
+    }
+    fn from_mat4_minor(m: Val<bevy::math::Mat4>, i: usize, j: usize) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_mat4_minor(
+                m.into_inner(),
+                i,
+                j,
+            )
+            .into();
+        output
+    }
+    fn from_quat(rotation: Val<bevy::math::Quat>) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_quat(
+                rotation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_rotation_x(angle: f32) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_rotation_x(angle)
+            .into();
+        output
+    }
+    fn from_rotation_y(angle: f32) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_rotation_y(angle)
+            .into();
+        output
+    }
+    fn from_rotation_z(angle: f32) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_rotation_z(angle)
+            .into();
+        output
+    }
+    fn from_scale(scale: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_scale(
+                scale.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_scale_angle_translation(
+        scale: Val<bevy::math::Vec2>,
+        angle: f32,
+        translation: Val<bevy::math::Vec2>,
+    ) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_scale_angle_translation(
+                scale.into_inner(),
+                angle,
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_translation(translation: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_translation(
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn inverse(_self: Ref<bevy::math::Mat3>) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::inverse(&_self).into();
+        output
+    }
+    fn is_finite(_self: Ref<bevy::math::Mat3>) {
+        let output: bool = bevy::math::Mat3::is_finite(&_self).into();
+        output
+    }
+    fn is_nan(_self: Ref<bevy::math::Mat3>) {
+        let output: bool = bevy::math::Mat3::is_nan(&_self).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Mat3>, rhs: Val<bevy::math::Affine2>) {
+        let output: Val<bevy::math::Mat3> = <bevy::math::Mat3 as std::ops::Mul<
+            bevy::math::Affine2,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Mat3>, rhs: Val<bevy::math::Mat3>) {
+        let output: Val<bevy::math::Mat3> = <bevy::math::Mat3 as std::ops::Mul<
+            bevy::math::Mat3,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Mat3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Mat3 as std::ops::Mul<
+            bevy::math::Vec3,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Mat3>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Mat3 as std::ops::Mul<
+            bevy::math::Vec3A,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Mat3>, rhs: f32) {
+        let output: Val<bevy::math::Mat3> = <bevy::math::Mat3 as std::ops::Mul<
+            f32,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn mul_mat3(_self: Ref<bevy::math::Mat3>, rhs: Ref<bevy::math::Mat3>) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::mul_mat3(&_self, &rhs)
+            .into();
+        output
+    }
+    fn mul_scalar(_self: Ref<bevy::math::Mat3>, rhs: f32) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::mul_scalar(&_self, rhs)
+            .into();
+        output
+    }
+    fn mul_vec3(_self: Ref<bevy::math::Mat3>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Mat3::mul_vec3(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn mul_vec3a(_self: Ref<bevy::math::Mat3>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Mat3::mul_vec3a(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::Mat3>) {
+        let output: Val<bevy::math::Mat3> = <bevy::math::Mat3 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn row(_self: Ref<bevy::math::Mat3>, index: usize) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Mat3::row(&_self, index).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::Mat3>, rhs: Val<bevy::math::Mat3>) {
+        let output: Val<bevy::math::Mat3> = <bevy::math::Mat3 as std::ops::Sub<
+            bevy::math::Mat3,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub_mat3(_self: Ref<bevy::math::Mat3>, rhs: Ref<bevy::math::Mat3>) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::sub_mat3(&_self, &rhs)
+            .into();
+        output
+    }
+    fn to_cols_array(_self: Ref<bevy::math::Mat3>) {
+        let output: [f32; 9] = bevy::math::Mat3::to_cols_array(&_self).into();
+        output
+    }
+    fn to_cols_array_2d(_self: Ref<bevy::math::Mat3>) {
+        let output: [[f32; 3]; 3] = bevy::math::Mat3::to_cols_array_2d(&_self).into();
+        output
+    }
+    fn to_euler(_self: Ref<bevy::math::Mat3>, order: Val<bevy::math::EulerRot>) {
+        let output: (f32, f32, f32) = bevy::math::Mat3::to_euler(
+                &_self,
+                order.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transform_point2(_self: Ref<bevy::math::Mat3>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Mat3::transform_point2(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transform_vector2(_self: Ref<bevy::math::Mat3>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Mat3::transform_vector2(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transpose(_self: Ref<bevy::math::Mat3>) {
+        let output: Val<bevy::math::Mat3> = bevy::math::Mat3::transpose(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "mat_3_a")]
+impl bevy::math::Mat3A {
+    fn abs(_self: Ref<bevy::math::Mat3A>) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::abs(&_self).into();
+        output
+    }
+    fn abs_diff_eq(
+        _self: Ref<bevy::math::Mat3A>,
+        rhs: Val<bevy::math::Mat3A>,
+        max_abs_diff: f32,
+    ) {
+        let output: bool = bevy::math::Mat3A::abs_diff_eq(
+                &_self,
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::Mat3A>, rhs: Val<bevy::math::Mat3A>) {
+        let output: Val<bevy::math::Mat3A> = <bevy::math::Mat3A as std::ops::Add<
+            bevy::math::Mat3A,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add_mat3(_self: Ref<bevy::math::Mat3A>, rhs: Ref<bevy::math::Mat3A>) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::add_mat3(&_self, &rhs)
+            .into();
+        output
+    }
+    fn as_dmat3(_self: Ref<bevy::math::Mat3A>) {
+        let output: Val<bevy::math::DMat3> = bevy::math::Mat3A::as_dmat3(&_self).into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::Mat3A>) {
+        let output: Val<bevy::math::Mat3A> = <bevy::math::Mat3A as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn col(_self: Ref<bevy::math::Mat3A>, index: usize) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Mat3A::col(&_self, index)
+            .into();
+        output
+    }
+    fn determinant(_self: Ref<bevy::math::Mat3A>) {
+        let output: f32 = bevy::math::Mat3A::determinant(&_self).into();
+        output
+    }
+    fn div(_self: Val<bevy::math::Mat3A>, rhs: f32) {
+        let output: Val<bevy::math::Mat3A> = <bevy::math::Mat3A as std::ops::Div<
+            f32,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_scalar(_self: Ref<bevy::math::Mat3A>, rhs: f32) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::div_scalar(&_self, rhs)
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::Mat3A>, rhs: Ref<bevy::math::Mat3A>) {
+        let output: bool = <bevy::math::Mat3A as std::cmp::PartialEq<
+            bevy::math::Mat3A,
+        >>::eq(&_self, &rhs)
+            .into();
+        output
+    }
+    fn from_angle(angle: f32) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_angle(angle).into();
+        output
+    }
+    fn from_axis_angle(axis: Val<bevy::math::Vec3>, angle: f32) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_axis_angle(
+                axis.into_inner(),
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_cols(
+        x_axis: Val<bevy::math::Vec3A>,
+        y_axis: Val<bevy::math::Vec3A>,
+        z_axis: Val<bevy::math::Vec3A>,
+    ) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_cols(
+                x_axis.into_inner(),
+                y_axis.into_inner(),
+                z_axis.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_diagonal(diagonal: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_diagonal(
+                diagonal.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_euler(order: Val<bevy::math::EulerRot>, a: f32, b: f32, c: f32) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_euler(
+                order.into_inner(),
+                a,
+                b,
+                c,
+            )
+            .into();
+        output
+    }
+    fn from_mat2(m: Val<bevy::math::Mat2>) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_mat2(m.into_inner())
+            .into();
+        output
+    }
+    fn from_mat4(m: Val<bevy::math::Mat4>) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_mat4(m.into_inner())
+            .into();
+        output
+    }
+    fn from_mat4_minor(m: Val<bevy::math::Mat4>, i: usize, j: usize) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_mat4_minor(
+                m.into_inner(),
+                i,
+                j,
+            )
+            .into();
+        output
+    }
+    fn from_quat(rotation: Val<bevy::math::Quat>) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_quat(
+                rotation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_rotation_x(angle: f32) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_rotation_x(angle)
+            .into();
+        output
+    }
+    fn from_rotation_y(angle: f32) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_rotation_y(angle)
+            .into();
+        output
+    }
+    fn from_rotation_z(angle: f32) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_rotation_z(angle)
+            .into();
+        output
+    }
+    fn from_scale(scale: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_scale(
+                scale.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_scale_angle_translation(
+        scale: Val<bevy::math::Vec2>,
+        angle: f32,
+        translation: Val<bevy::math::Vec2>,
+    ) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_scale_angle_translation(
+                scale.into_inner(),
+                angle,
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_translation(translation: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_translation(
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn inverse(_self: Ref<bevy::math::Mat3A>) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::inverse(&_self).into();
+        output
+    }
+    fn is_finite(_self: Ref<bevy::math::Mat3A>) {
+        let output: bool = bevy::math::Mat3A::is_finite(&_self).into();
+        output
+    }
+    fn is_nan(_self: Ref<bevy::math::Mat3A>) {
+        let output: bool = bevy::math::Mat3A::is_nan(&_self).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Mat3A>, rhs: Val<bevy::math::Affine2>) {
+        let output: Val<bevy::math::Mat3A> = <bevy::math::Mat3A as std::ops::Mul<
+            bevy::math::Affine2,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Mat3A>, rhs: Val<bevy::math::Mat3A>) {
+        let output: Val<bevy::math::Mat3A> = <bevy::math::Mat3A as std::ops::Mul<
+            bevy::math::Mat3A,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Mat3A>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = <bevy::math::Mat3A as std::ops::Mul<
+            bevy::math::Vec3,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Mat3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = <bevy::math::Mat3A as std::ops::Mul<
+            bevy::math::Vec3A,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Mat3A>, rhs: f32) {
+        let output: Val<bevy::math::Mat3A> = <bevy::math::Mat3A as std::ops::Mul<
+            f32,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn mul_mat3(_self: Ref<bevy::math::Mat3A>, rhs: Ref<bevy::math::Mat3A>) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::mul_mat3(&_self, &rhs)
+            .into();
+        output
+    }
+    fn mul_scalar(_self: Ref<bevy::math::Mat3A>, rhs: f32) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::mul_scalar(&_self, rhs)
+            .into();
+        output
+    }
+    fn mul_vec3(_self: Ref<bevy::math::Mat3A>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Mat3A::mul_vec3(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn mul_vec3a(_self: Ref<bevy::math::Mat3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Mat3A::mul_vec3a(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::Mat3A>) {
+        let output: Val<bevy::math::Mat3A> = <bevy::math::Mat3A as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn row(_self: Ref<bevy::math::Mat3A>, index: usize) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Mat3A::row(&_self, index)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::Mat3A>, rhs: Val<bevy::math::Mat3A>) {
+        let output: Val<bevy::math::Mat3A> = <bevy::math::Mat3A as std::ops::Sub<
+            bevy::math::Mat3A,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub_mat3(_self: Ref<bevy::math::Mat3A>, rhs: Ref<bevy::math::Mat3A>) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::sub_mat3(&_self, &rhs)
+            .into();
+        output
+    }
+    fn to_cols_array(_self: Ref<bevy::math::Mat3A>) {
+        let output: [f32; 9] = bevy::math::Mat3A::to_cols_array(&_self).into();
+        output
+    }
+    fn to_cols_array_2d(_self: Ref<bevy::math::Mat3A>) {
+        let output: [[f32; 3]; 3] = bevy::math::Mat3A::to_cols_array_2d(&_self).into();
+        output
+    }
+    fn to_euler(_self: Ref<bevy::math::Mat3A>, order: Val<bevy::math::EulerRot>) {
+        let output: (f32, f32, f32) = bevy::math::Mat3A::to_euler(
+                &_self,
+                order.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transform_point2(_self: Ref<bevy::math::Mat3A>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Mat3A::transform_point2(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transform_vector2(_self: Ref<bevy::math::Mat3A>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Mat3A::transform_vector2(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transpose(_self: Ref<bevy::math::Mat3A>) {
+        let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::transpose(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "mat_4")]
+impl bevy::math::Mat4 {
+    fn abs(_self: Ref<bevy::math::Mat4>) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::abs(&_self).into();
+        output
+    }
+    fn abs_diff_eq(
+        _self: Ref<bevy::math::Mat4>,
+        rhs: Val<bevy::math::Mat4>,
+        max_abs_diff: f32,
+    ) {
+        let output: bool = bevy::math::Mat4::abs_diff_eq(
+                &_self,
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::Mat4>, rhs: Val<bevy::math::Mat4>) {
+        let output: Val<bevy::math::Mat4> = <bevy::math::Mat4 as std::ops::Add<
+            bevy::math::Mat4,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add_mat4(_self: Ref<bevy::math::Mat4>, rhs: Ref<bevy::math::Mat4>) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::add_mat4(&_self, &rhs)
+            .into();
+        output
+    }
+    fn as_dmat4(_self: Ref<bevy::math::Mat4>) {
+        let output: Val<bevy::math::DMat4> = bevy::math::Mat4::as_dmat4(&_self).into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::Mat4>) {
+        let output: Val<bevy::math::Mat4> = <bevy::math::Mat4 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn col(_self: Ref<bevy::math::Mat4>, index: usize) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Mat4::col(&_self, index).into();
+        output
+    }
+    fn determinant(_self: Ref<bevy::math::Mat4>) {
+        let output: f32 = bevy::math::Mat4::determinant(&_self).into();
+        output
+    }
+    fn div(_self: Val<bevy::math::Mat4>, rhs: f32) {
+        let output: Val<bevy::math::Mat4> = <bevy::math::Mat4 as std::ops::Div<
+            f32,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_scalar(_self: Ref<bevy::math::Mat4>, rhs: f32) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::div_scalar(&_self, rhs)
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::Mat4>, rhs: Ref<bevy::math::Mat4>) {
+        let output: bool = <bevy::math::Mat4 as std::cmp::PartialEq<
+            bevy::math::Mat4,
+        >>::eq(&_self, &rhs)
+            .into();
+        output
+    }
+    fn from_axis_angle(axis: Val<bevy::math::Vec3>, angle: f32) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_axis_angle(
+                axis.into_inner(),
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_cols(
+        x_axis: Val<bevy::math::Vec4>,
+        y_axis: Val<bevy::math::Vec4>,
+        z_axis: Val<bevy::math::Vec4>,
+        w_axis: Val<bevy::math::Vec4>,
+    ) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_cols(
+                x_axis.into_inner(),
+                y_axis.into_inner(),
+                z_axis.into_inner(),
+                w_axis.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_diagonal(diagonal: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_diagonal(
+                diagonal.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_euler(order: Val<bevy::math::EulerRot>, a: f32, b: f32, c: f32) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_euler(
+                order.into_inner(),
+                a,
+                b,
+                c,
+            )
+            .into();
+        output
+    }
+    fn from_mat3(m: Val<bevy::math::Mat3>) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_mat3(m.into_inner())
+            .into();
+        output
+    }
+    fn from_mat3a(m: Val<bevy::math::Mat3A>) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_mat3a(m.into_inner())
+            .into();
+        output
+    }
+    fn from_quat(rotation: Val<bevy::math::Quat>) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_quat(
+                rotation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_rotation_translation(
+        rotation: Val<bevy::math::Quat>,
+        translation: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_rotation_translation(
+                rotation.into_inner(),
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_rotation_x(angle: f32) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_rotation_x(angle)
+            .into();
+        output
+    }
+    fn from_rotation_y(angle: f32) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_rotation_y(angle)
+            .into();
+        output
+    }
+    fn from_rotation_z(angle: f32) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_rotation_z(angle)
+            .into();
+        output
+    }
+    fn from_scale(scale: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_scale(
+                scale.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_scale_rotation_translation(
+        scale: Val<bevy::math::Vec3>,
+        rotation: Val<bevy::math::Quat>,
+        translation: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_scale_rotation_translation(
+                scale.into_inner(),
+                rotation.into_inner(),
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_translation(translation: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_translation(
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn inverse(_self: Ref<bevy::math::Mat4>) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::inverse(&_self).into();
+        output
+    }
+    fn is_finite(_self: Ref<bevy::math::Mat4>) {
+        let output: bool = bevy::math::Mat4::is_finite(&_self).into();
+        output
+    }
+    fn is_nan(_self: Ref<bevy::math::Mat4>) {
+        let output: bool = bevy::math::Mat4::is_nan(&_self).into();
+        output
+    }
+    fn look_at_lh(
+        eye: Val<bevy::math::Vec3>,
+        center: Val<bevy::math::Vec3>,
+        up: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::look_at_lh(
+                eye.into_inner(),
+                center.into_inner(),
+                up.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn look_at_rh(
+        eye: Val<bevy::math::Vec3>,
+        center: Val<bevy::math::Vec3>,
+        up: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::look_at_rh(
+                eye.into_inner(),
+                center.into_inner(),
+                up.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn look_to_lh(
+        eye: Val<bevy::math::Vec3>,
+        dir: Val<bevy::math::Vec3>,
+        up: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::look_to_lh(
+                eye.into_inner(),
+                dir.into_inner(),
+                up.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn look_to_rh(
+        eye: Val<bevy::math::Vec3>,
+        dir: Val<bevy::math::Vec3>,
+        up: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::look_to_rh(
+                eye.into_inner(),
+                dir.into_inner(),
+                up.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Mat4>, rhs: Val<bevy::math::Affine3A>) {
+        let output: Val<bevy::math::Mat4> = <bevy::math::Mat4 as std::ops::Mul<
+            bevy::math::Affine3A,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Mat4>, rhs: Val<bevy::math::Mat4>) {
+        let output: Val<bevy::math::Mat4> = <bevy::math::Mat4 as std::ops::Mul<
+            bevy::math::Mat4,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Mat4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = <bevy::math::Mat4 as std::ops::Mul<
+            bevy::math::Vec4,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Mat4>, rhs: f32) {
+        let output: Val<bevy::math::Mat4> = <bevy::math::Mat4 as std::ops::Mul<
+            f32,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn mul_mat4(_self: Ref<bevy::math::Mat4>, rhs: Ref<bevy::math::Mat4>) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::mul_mat4(&_self, &rhs)
+            .into();
+        output
+    }
+    fn mul_scalar(_self: Ref<bevy::math::Mat4>, rhs: f32) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::mul_scalar(&_self, rhs)
+            .into();
+        output
+    }
+    fn mul_vec4(_self: Ref<bevy::math::Mat4>, rhs: Val<bevy::math::Vec4>) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Mat4::mul_vec4(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::Mat4>) {
+        let output: Val<bevy::math::Mat4> = <bevy::math::Mat4 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn orthographic_lh(
+        left: f32,
+        right: f32,
+        bottom: f32,
+        top: f32,
+        near: f32,
+        far: f32,
+    ) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::orthographic_lh(
+                left,
+                right,
+                bottom,
+                top,
+                near,
+                far,
+            )
+            .into();
+        output
+    }
+    fn orthographic_rh(
+        left: f32,
+        right: f32,
+        bottom: f32,
+        top: f32,
+        near: f32,
+        far: f32,
+    ) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::orthographic_rh(
+                left,
+                right,
+                bottom,
+                top,
+                near,
+                far,
+            )
+            .into();
+        output
+    }
+    fn orthographic_rh_gl(
+        left: f32,
+        right: f32,
+        bottom: f32,
+        top: f32,
+        near: f32,
+        far: f32,
+    ) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::orthographic_rh_gl(
+                left,
+                right,
+                bottom,
+                top,
+                near,
+                far,
+            )
+            .into();
+        output
+    }
+    fn perspective_infinite_lh(fov_y_radians: f32, aspect_ratio: f32, z_near: f32) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::perspective_infinite_lh(
+                fov_y_radians,
+                aspect_ratio,
+                z_near,
+            )
+            .into();
+        output
+    }
+    fn perspective_infinite_reverse_lh(
+        fov_y_radians: f32,
+        aspect_ratio: f32,
+        z_near: f32,
+    ) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::perspective_infinite_reverse_lh(
+                fov_y_radians,
+                aspect_ratio,
+                z_near,
+            )
+            .into();
+        output
+    }
+    fn perspective_infinite_reverse_rh(
+        fov_y_radians: f32,
+        aspect_ratio: f32,
+        z_near: f32,
+    ) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::perspective_infinite_reverse_rh(
+                fov_y_radians,
+                aspect_ratio,
+                z_near,
+            )
+            .into();
+        output
+    }
+    fn perspective_infinite_rh(fov_y_radians: f32, aspect_ratio: f32, z_near: f32) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::perspective_infinite_rh(
+                fov_y_radians,
+                aspect_ratio,
+                z_near,
+            )
+            .into();
+        output
+    }
+    fn perspective_lh(fov_y_radians: f32, aspect_ratio: f32, z_near: f32, z_far: f32) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::perspective_lh(
+                fov_y_radians,
+                aspect_ratio,
+                z_near,
+                z_far,
+            )
+            .into();
+        output
+    }
+    fn perspective_rh(fov_y_radians: f32, aspect_ratio: f32, z_near: f32, z_far: f32) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::perspective_rh(
+                fov_y_radians,
+                aspect_ratio,
+                z_near,
+                z_far,
+            )
+            .into();
+        output
+    }
+    fn perspective_rh_gl(
+        fov_y_radians: f32,
+        aspect_ratio: f32,
+        z_near: f32,
+        z_far: f32,
+    ) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::perspective_rh_gl(
+                fov_y_radians,
+                aspect_ratio,
+                z_near,
+                z_far,
+            )
+            .into();
+        output
+    }
+    fn project_point3(_self: Ref<bevy::math::Mat4>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Mat4::project_point3(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn project_point3a(_self: Ref<bevy::math::Mat4>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Mat4::project_point3a(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn row(_self: Ref<bevy::math::Mat4>, index: usize) {
+        let output: Val<bevy::math::Vec4> = bevy::math::Mat4::row(&_self, index).into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::Mat4>, rhs: Val<bevy::math::Mat4>) {
+        let output: Val<bevy::math::Mat4> = <bevy::math::Mat4 as std::ops::Sub<
+            bevy::math::Mat4,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub_mat4(_self: Ref<bevy::math::Mat4>, rhs: Ref<bevy::math::Mat4>) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::sub_mat4(&_self, &rhs)
+            .into();
+        output
+    }
+    fn to_cols_array(_self: Ref<bevy::math::Mat4>) {
+        let output: [f32; 16] = bevy::math::Mat4::to_cols_array(&_self).into();
+        output
+    }
+    fn to_cols_array_2d(_self: Ref<bevy::math::Mat4>) {
+        let output: [[f32; 4]; 4] = bevy::math::Mat4::to_cols_array_2d(&_self).into();
+        output
+    }
+    fn to_euler(_self: Ref<bevy::math::Mat4>, order: Val<bevy::math::EulerRot>) {
+        let output: (f32, f32, f32) = bevy::math::Mat4::to_euler(
+                &_self,
+                order.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transform_point3(_self: Ref<bevy::math::Mat4>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Mat4::transform_point3(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transform_point3a(_self: Ref<bevy::math::Mat4>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Mat4::transform_point3a(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transform_vector3(_self: Ref<bevy::math::Mat4>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Mat4::transform_vector3(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transform_vector3a(_self: Ref<bevy::math::Mat4>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Mat4::transform_vector3a(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transpose(_self: Ref<bevy::math::Mat4>) {
+        let output: Val<bevy::math::Mat4> = bevy::math::Mat4::transpose(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "d_mat_2")]
+impl bevy::math::DMat2 {
+    fn abs(_self: Ref<bevy::math::DMat2>) {
+        let output: Val<bevy::math::DMat2> = bevy::math::DMat2::abs(&_self).into();
+        output
+    }
+    fn abs_diff_eq(
+        _self: Ref<bevy::math::DMat2>,
+        rhs: Val<bevy::math::DMat2>,
+        max_abs_diff: f64,
+    ) {
+        let output: bool = bevy::math::DMat2::abs_diff_eq(
+                &_self,
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::DMat2>, rhs: Val<bevy::math::DMat2>) {
+        let output: Val<bevy::math::DMat2> = <bevy::math::DMat2 as std::ops::Add<
+            bevy::math::DMat2,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add_mat2(_self: Ref<bevy::math::DMat2>, rhs: Ref<bevy::math::DMat2>) {
+        let output: Val<bevy::math::DMat2> = bevy::math::DMat2::add_mat2(&_self, &rhs)
+            .into();
+        output
+    }
+    fn as_mat2(_self: Ref<bevy::math::DMat2>) {
+        let output: Val<bevy::math::Mat2> = bevy::math::DMat2::as_mat2(&_self).into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::DMat2>) {
+        let output: Val<bevy::math::DMat2> = <bevy::math::DMat2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn col(_self: Ref<bevy::math::DMat2>, index: usize) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DMat2::col(&_self, index)
+            .into();
+        output
+    }
+    fn determinant(_self: Ref<bevy::math::DMat2>) {
+        let output: f64 = bevy::math::DMat2::determinant(&_self).into();
+        output
+    }
+    fn div(_self: Val<bevy::math::DMat2>, rhs: f64) {
+        let output: Val<bevy::math::DMat2> = <bevy::math::DMat2 as std::ops::Div<
+            f64,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_scalar(_self: Ref<bevy::math::DMat2>, rhs: f64) {
+        let output: Val<bevy::math::DMat2> = bevy::math::DMat2::div_scalar(&_self, rhs)
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::DMat2>, rhs: Ref<bevy::math::DMat2>) {
+        let output: bool = <bevy::math::DMat2 as std::cmp::PartialEq<
+            bevy::math::DMat2,
+        >>::eq(&_self, &rhs)
+            .into();
+        output
+    }
+    fn from_angle(angle: f64) {
+        let output: Val<bevy::math::DMat2> = bevy::math::DMat2::from_angle(angle).into();
+        output
+    }
+    fn from_cols(x_axis: Val<bevy::math::DVec2>, y_axis: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DMat2> = bevy::math::DMat2::from_cols(
+                x_axis.into_inner(),
+                y_axis.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_diagonal(diagonal: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DMat2> = bevy::math::DMat2::from_diagonal(
+                diagonal.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_mat3(m: Val<bevy::math::DMat3>) {
+        let output: Val<bevy::math::DMat2> = bevy::math::DMat2::from_mat3(m.into_inner())
+            .into();
+        output
+    }
+    fn from_mat3_minor(m: Val<bevy::math::DMat3>, i: usize, j: usize) {
+        let output: Val<bevy::math::DMat2> = bevy::math::DMat2::from_mat3_minor(
+                m.into_inner(),
+                i,
+                j,
+            )
+            .into();
+        output
+    }
+    fn from_scale_angle(scale: Val<bevy::math::DVec2>, angle: f64) {
+        let output: Val<bevy::math::DMat2> = bevy::math::DMat2::from_scale_angle(
+                scale.into_inner(),
+                angle,
+            )
+            .into();
+        output
+    }
+    fn inverse(_self: Ref<bevy::math::DMat2>) {
+        let output: Val<bevy::math::DMat2> = bevy::math::DMat2::inverse(&_self).into();
+        output
+    }
+    fn is_finite(_self: Ref<bevy::math::DMat2>) {
+        let output: bool = bevy::math::DMat2::is_finite(&_self).into();
+        output
+    }
+    fn is_nan(_self: Ref<bevy::math::DMat2>) {
+        let output: bool = bevy::math::DMat2::is_nan(&_self).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DMat2>, rhs: Val<bevy::math::DMat2>) {
+        let output: Val<bevy::math::DMat2> = <bevy::math::DMat2 as std::ops::Mul<
+            bevy::math::DMat2,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DMat2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = <bevy::math::DMat2 as std::ops::Mul<
+            bevy::math::DVec2,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DMat2>, rhs: f64) {
+        let output: Val<bevy::math::DMat2> = <bevy::math::DMat2 as std::ops::Mul<
+            f64,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn mul_mat2(_self: Ref<bevy::math::DMat2>, rhs: Ref<bevy::math::DMat2>) {
+        let output: Val<bevy::math::DMat2> = bevy::math::DMat2::mul_mat2(&_self, &rhs)
+            .into();
+        output
+    }
+    fn mul_scalar(_self: Ref<bevy::math::DMat2>, rhs: f64) {
+        let output: Val<bevy::math::DMat2> = bevy::math::DMat2::mul_scalar(&_self, rhs)
+            .into();
+        output
+    }
+    fn mul_vec2(_self: Ref<bevy::math::DMat2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DMat2::mul_vec2(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::DMat2>) {
+        let output: Val<bevy::math::DMat2> = <bevy::math::DMat2 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn row(_self: Ref<bevy::math::DMat2>, index: usize) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DMat2::row(&_self, index)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::DMat2>, rhs: Val<bevy::math::DMat2>) {
+        let output: Val<bevy::math::DMat2> = <bevy::math::DMat2 as std::ops::Sub<
+            bevy::math::DMat2,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub_mat2(_self: Ref<bevy::math::DMat2>, rhs: Ref<bevy::math::DMat2>) {
+        let output: Val<bevy::math::DMat2> = bevy::math::DMat2::sub_mat2(&_self, &rhs)
+            .into();
+        output
+    }
+    fn to_cols_array(_self: Ref<bevy::math::DMat2>) {
+        let output: [f64; 4] = bevy::math::DMat2::to_cols_array(&_self).into();
+        output
+    }
+    fn to_cols_array_2d(_self: Ref<bevy::math::DMat2>) {
+        let output: [[f64; 2]; 2] = bevy::math::DMat2::to_cols_array_2d(&_self).into();
+        output
+    }
+    fn transpose(_self: Ref<bevy::math::DMat2>) {
+        let output: Val<bevy::math::DMat2> = bevy::math::DMat2::transpose(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "d_mat_3")]
+impl bevy::math::DMat3 {
+    fn abs(_self: Ref<bevy::math::DMat3>) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::abs(&_self).into();
+        output
+    }
+    fn abs_diff_eq(
+        _self: Ref<bevy::math::DMat3>,
+        rhs: Val<bevy::math::DMat3>,
+        max_abs_diff: f64,
+    ) {
+        let output: bool = bevy::math::DMat3::abs_diff_eq(
+                &_self,
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::DMat3>, rhs: Val<bevy::math::DMat3>) {
+        let output: Val<bevy::math::DMat3> = <bevy::math::DMat3 as std::ops::Add<
+            bevy::math::DMat3,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add_mat3(_self: Ref<bevy::math::DMat3>, rhs: Ref<bevy::math::DMat3>) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::add_mat3(&_self, &rhs)
+            .into();
+        output
+    }
+    fn as_mat3(_self: Ref<bevy::math::DMat3>) {
+        let output: Val<bevy::math::Mat3> = bevy::math::DMat3::as_mat3(&_self).into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::DMat3>) {
+        let output: Val<bevy::math::DMat3> = <bevy::math::DMat3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn col(_self: Ref<bevy::math::DMat3>, index: usize) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DMat3::col(&_self, index)
+            .into();
+        output
+    }
+    fn determinant(_self: Ref<bevy::math::DMat3>) {
+        let output: f64 = bevy::math::DMat3::determinant(&_self).into();
+        output
+    }
+    fn div(_self: Val<bevy::math::DMat3>, rhs: f64) {
+        let output: Val<bevy::math::DMat3> = <bevy::math::DMat3 as std::ops::Div<
+            f64,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_scalar(_self: Ref<bevy::math::DMat3>, rhs: f64) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::div_scalar(&_self, rhs)
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::DMat3>, rhs: Ref<bevy::math::DMat3>) {
+        let output: bool = <bevy::math::DMat3 as std::cmp::PartialEq<
+            bevy::math::DMat3,
+        >>::eq(&_self, &rhs)
+            .into();
+        output
+    }
+    fn from_angle(angle: f64) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_angle(angle).into();
+        output
+    }
+    fn from_axis_angle(axis: Val<bevy::math::DVec3>, angle: f64) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_axis_angle(
+                axis.into_inner(),
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_cols(
+        x_axis: Val<bevy::math::DVec3>,
+        y_axis: Val<bevy::math::DVec3>,
+        z_axis: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_cols(
+                x_axis.into_inner(),
+                y_axis.into_inner(),
+                z_axis.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_diagonal(diagonal: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_diagonal(
+                diagonal.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_euler(order: Val<bevy::math::EulerRot>, a: f64, b: f64, c: f64) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_euler(
+                order.into_inner(),
+                a,
+                b,
+                c,
+            )
+            .into();
+        output
+    }
+    fn from_mat2(m: Val<bevy::math::DMat2>) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_mat2(m.into_inner())
+            .into();
+        output
+    }
+    fn from_mat4(m: Val<bevy::math::DMat4>) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_mat4(m.into_inner())
+            .into();
+        output
+    }
+    fn from_mat4_minor(m: Val<bevy::math::DMat4>, i: usize, j: usize) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_mat4_minor(
+                m.into_inner(),
+                i,
+                j,
+            )
+            .into();
+        output
+    }
+    fn from_quat(rotation: Val<bevy::math::DQuat>) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_quat(
+                rotation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_rotation_x(angle: f64) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_rotation_x(angle)
+            .into();
+        output
+    }
+    fn from_rotation_y(angle: f64) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_rotation_y(angle)
+            .into();
+        output
+    }
+    fn from_rotation_z(angle: f64) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_rotation_z(angle)
+            .into();
+        output
+    }
+    fn from_scale(scale: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_scale(
+                scale.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_scale_angle_translation(
+        scale: Val<bevy::math::DVec2>,
+        angle: f64,
+        translation: Val<bevy::math::DVec2>,
+    ) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_scale_angle_translation(
+                scale.into_inner(),
+                angle,
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_translation(translation: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_translation(
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn inverse(_self: Ref<bevy::math::DMat3>) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::inverse(&_self).into();
+        output
+    }
+    fn is_finite(_self: Ref<bevy::math::DMat3>) {
+        let output: bool = bevy::math::DMat3::is_finite(&_self).into();
+        output
+    }
+    fn is_nan(_self: Ref<bevy::math::DMat3>) {
+        let output: bool = bevy::math::DMat3::is_nan(&_self).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DMat3>, rhs: Val<bevy::math::DAffine2>) {
+        let output: Val<bevy::math::DMat3> = <bevy::math::DMat3 as std::ops::Mul<
+            bevy::math::DAffine2,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DMat3>, rhs: Val<bevy::math::DMat3>) {
+        let output: Val<bevy::math::DMat3> = <bevy::math::DMat3 as std::ops::Mul<
+            bevy::math::DMat3,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DMat3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = <bevy::math::DMat3 as std::ops::Mul<
+            bevy::math::DVec3,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DMat3>, rhs: f64) {
+        let output: Val<bevy::math::DMat3> = <bevy::math::DMat3 as std::ops::Mul<
+            f64,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn mul_mat3(_self: Ref<bevy::math::DMat3>, rhs: Ref<bevy::math::DMat3>) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::mul_mat3(&_self, &rhs)
+            .into();
+        output
+    }
+    fn mul_scalar(_self: Ref<bevy::math::DMat3>, rhs: f64) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::mul_scalar(&_self, rhs)
+            .into();
+        output
+    }
+    fn mul_vec3(_self: Ref<bevy::math::DMat3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DMat3::mul_vec3(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::DMat3>) {
+        let output: Val<bevy::math::DMat3> = <bevy::math::DMat3 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn row(_self: Ref<bevy::math::DMat3>, index: usize) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DMat3::row(&_self, index)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::DMat3>, rhs: Val<bevy::math::DMat3>) {
+        let output: Val<bevy::math::DMat3> = <bevy::math::DMat3 as std::ops::Sub<
+            bevy::math::DMat3,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub_mat3(_self: Ref<bevy::math::DMat3>, rhs: Ref<bevy::math::DMat3>) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::sub_mat3(&_self, &rhs)
+            .into();
+        output
+    }
+    fn to_cols_array(_self: Ref<bevy::math::DMat3>) {
+        let output: [f64; 9] = bevy::math::DMat3::to_cols_array(&_self).into();
+        output
+    }
+    fn to_cols_array_2d(_self: Ref<bevy::math::DMat3>) {
+        let output: [[f64; 3]; 3] = bevy::math::DMat3::to_cols_array_2d(&_self).into();
+        output
+    }
+    fn to_euler(_self: Ref<bevy::math::DMat3>, order: Val<bevy::math::EulerRot>) {
+        let output: (f64, f64, f64) = bevy::math::DMat3::to_euler(
+                &_self,
+                order.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transform_point2(_self: Ref<bevy::math::DMat3>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DMat3::transform_point2(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transform_vector2(_self: Ref<bevy::math::DMat3>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DMat3::transform_vector2(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transpose(_self: Ref<bevy::math::DMat3>) {
+        let output: Val<bevy::math::DMat3> = bevy::math::DMat3::transpose(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "d_mat_4")]
+impl bevy::math::DMat4 {
+    fn abs(_self: Ref<bevy::math::DMat4>) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::abs(&_self).into();
+        output
+    }
+    fn abs_diff_eq(
+        _self: Ref<bevy::math::DMat4>,
+        rhs: Val<bevy::math::DMat4>,
+        max_abs_diff: f64,
+    ) {
+        let output: bool = bevy::math::DMat4::abs_diff_eq(
+                &_self,
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::DMat4>, rhs: Val<bevy::math::DMat4>) {
+        let output: Val<bevy::math::DMat4> = <bevy::math::DMat4 as std::ops::Add<
+            bevy::math::DMat4,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn add_mat4(_self: Ref<bevy::math::DMat4>, rhs: Ref<bevy::math::DMat4>) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::add_mat4(&_self, &rhs)
+            .into();
+        output
+    }
+    fn as_mat4(_self: Ref<bevy::math::DMat4>) {
+        let output: Val<bevy::math::Mat4> = bevy::math::DMat4::as_mat4(&_self).into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::DMat4>) {
+        let output: Val<bevy::math::DMat4> = <bevy::math::DMat4 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn col(_self: Ref<bevy::math::DMat4>, index: usize) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DMat4::col(&_self, index)
+            .into();
+        output
+    }
+    fn determinant(_self: Ref<bevy::math::DMat4>) {
+        let output: f64 = bevy::math::DMat4::determinant(&_self).into();
+        output
+    }
+    fn div(_self: Val<bevy::math::DMat4>, rhs: f64) {
+        let output: Val<bevy::math::DMat4> = <bevy::math::DMat4 as std::ops::Div<
+            f64,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn div_scalar(_self: Ref<bevy::math::DMat4>, rhs: f64) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::div_scalar(&_self, rhs)
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::DMat4>, rhs: Ref<bevy::math::DMat4>) {
+        let output: bool = <bevy::math::DMat4 as std::cmp::PartialEq<
+            bevy::math::DMat4,
+        >>::eq(&_self, &rhs)
+            .into();
+        output
+    }
+    fn from_axis_angle(axis: Val<bevy::math::DVec3>, angle: f64) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_axis_angle(
+                axis.into_inner(),
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_cols(
+        x_axis: Val<bevy::math::DVec4>,
+        y_axis: Val<bevy::math::DVec4>,
+        z_axis: Val<bevy::math::DVec4>,
+        w_axis: Val<bevy::math::DVec4>,
+    ) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_cols(
+                x_axis.into_inner(),
+                y_axis.into_inner(),
+                z_axis.into_inner(),
+                w_axis.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_diagonal(diagonal: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_diagonal(
+                diagonal.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_euler(order: Val<bevy::math::EulerRot>, a: f64, b: f64, c: f64) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_euler(
+                order.into_inner(),
+                a,
+                b,
+                c,
+            )
+            .into();
+        output
+    }
+    fn from_mat3(m: Val<bevy::math::DMat3>) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_mat3(m.into_inner())
+            .into();
+        output
+    }
+    fn from_quat(rotation: Val<bevy::math::DQuat>) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_quat(
+                rotation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_rotation_translation(
+        rotation: Val<bevy::math::DQuat>,
+        translation: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_rotation_translation(
+                rotation.into_inner(),
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_rotation_x(angle: f64) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_rotation_x(angle)
+            .into();
+        output
+    }
+    fn from_rotation_y(angle: f64) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_rotation_y(angle)
+            .into();
+        output
+    }
+    fn from_rotation_z(angle: f64) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_rotation_z(angle)
+            .into();
+        output
+    }
+    fn from_scale(scale: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_scale(
+                scale.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_scale_rotation_translation(
+        scale: Val<bevy::math::DVec3>,
+        rotation: Val<bevy::math::DQuat>,
+        translation: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_scale_rotation_translation(
+                scale.into_inner(),
+                rotation.into_inner(),
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_translation(translation: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_translation(
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn inverse(_self: Ref<bevy::math::DMat4>) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::inverse(&_self).into();
+        output
+    }
+    fn is_finite(_self: Ref<bevy::math::DMat4>) {
+        let output: bool = bevy::math::DMat4::is_finite(&_self).into();
+        output
+    }
+    fn is_nan(_self: Ref<bevy::math::DMat4>) {
+        let output: bool = bevy::math::DMat4::is_nan(&_self).into();
+        output
+    }
+    fn look_at_lh(
+        eye: Val<bevy::math::DVec3>,
+        center: Val<bevy::math::DVec3>,
+        up: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::look_at_lh(
+                eye.into_inner(),
+                center.into_inner(),
+                up.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn look_at_rh(
+        eye: Val<bevy::math::DVec3>,
+        center: Val<bevy::math::DVec3>,
+        up: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::look_at_rh(
+                eye.into_inner(),
+                center.into_inner(),
+                up.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn look_to_lh(
+        eye: Val<bevy::math::DVec3>,
+        dir: Val<bevy::math::DVec3>,
+        up: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::look_to_lh(
+                eye.into_inner(),
+                dir.into_inner(),
+                up.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn look_to_rh(
+        eye: Val<bevy::math::DVec3>,
+        dir: Val<bevy::math::DVec3>,
+        up: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::look_to_rh(
+                eye.into_inner(),
+                dir.into_inner(),
+                up.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DMat4>, rhs: Val<bevy::math::DAffine3>) {
+        let output: Val<bevy::math::DMat4> = <bevy::math::DMat4 as std::ops::Mul<
+            bevy::math::DAffine3,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DMat4>, rhs: Val<bevy::math::DMat4>) {
+        let output: Val<bevy::math::DMat4> = <bevy::math::DMat4 as std::ops::Mul<
+            bevy::math::DMat4,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DMat4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = <bevy::math::DMat4 as std::ops::Mul<
+            bevy::math::DVec4,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DMat4>, rhs: f64) {
+        let output: Val<bevy::math::DMat4> = <bevy::math::DMat4 as std::ops::Mul<
+            f64,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn mul_mat4(_self: Ref<bevy::math::DMat4>, rhs: Ref<bevy::math::DMat4>) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::mul_mat4(&_self, &rhs)
+            .into();
+        output
+    }
+    fn mul_scalar(_self: Ref<bevy::math::DMat4>, rhs: f64) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::mul_scalar(&_self, rhs)
+            .into();
+        output
+    }
+    fn mul_vec4(_self: Ref<bevy::math::DMat4>, rhs: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DMat4::mul_vec4(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::DMat4>) {
+        let output: Val<bevy::math::DMat4> = <bevy::math::DMat4 as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn orthographic_lh(
+        left: f64,
+        right: f64,
+        bottom: f64,
+        top: f64,
+        near: f64,
+        far: f64,
+    ) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::orthographic_lh(
+                left,
+                right,
+                bottom,
+                top,
+                near,
+                far,
+            )
+            .into();
+        output
+    }
+    fn orthographic_rh(
+        left: f64,
+        right: f64,
+        bottom: f64,
+        top: f64,
+        near: f64,
+        far: f64,
+    ) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::orthographic_rh(
+                left,
+                right,
+                bottom,
+                top,
+                near,
+                far,
+            )
+            .into();
+        output
+    }
+    fn orthographic_rh_gl(
+        left: f64,
+        right: f64,
+        bottom: f64,
+        top: f64,
+        near: f64,
+        far: f64,
+    ) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::orthographic_rh_gl(
+                left,
+                right,
+                bottom,
+                top,
+                near,
+                far,
+            )
+            .into();
+        output
+    }
+    fn perspective_infinite_lh(fov_y_radians: f64, aspect_ratio: f64, z_near: f64) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::perspective_infinite_lh(
+                fov_y_radians,
+                aspect_ratio,
+                z_near,
+            )
+            .into();
+        output
+    }
+    fn perspective_infinite_reverse_lh(
+        fov_y_radians: f64,
+        aspect_ratio: f64,
+        z_near: f64,
+    ) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::perspective_infinite_reverse_lh(
+                fov_y_radians,
+                aspect_ratio,
+                z_near,
+            )
+            .into();
+        output
+    }
+    fn perspective_infinite_reverse_rh(
+        fov_y_radians: f64,
+        aspect_ratio: f64,
+        z_near: f64,
+    ) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::perspective_infinite_reverse_rh(
+                fov_y_radians,
+                aspect_ratio,
+                z_near,
+            )
+            .into();
+        output
+    }
+    fn perspective_infinite_rh(fov_y_radians: f64, aspect_ratio: f64, z_near: f64) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::perspective_infinite_rh(
+                fov_y_radians,
+                aspect_ratio,
+                z_near,
+            )
+            .into();
+        output
+    }
+    fn perspective_lh(fov_y_radians: f64, aspect_ratio: f64, z_near: f64, z_far: f64) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::perspective_lh(
+                fov_y_radians,
+                aspect_ratio,
+                z_near,
+                z_far,
+            )
+            .into();
+        output
+    }
+    fn perspective_rh(fov_y_radians: f64, aspect_ratio: f64, z_near: f64, z_far: f64) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::perspective_rh(
+                fov_y_radians,
+                aspect_ratio,
+                z_near,
+                z_far,
+            )
+            .into();
+        output
+    }
+    fn perspective_rh_gl(
+        fov_y_radians: f64,
+        aspect_ratio: f64,
+        z_near: f64,
+        z_far: f64,
+    ) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::perspective_rh_gl(
+                fov_y_radians,
+                aspect_ratio,
+                z_near,
+                z_far,
+            )
+            .into();
+        output
+    }
+    fn project_point3(_self: Ref<bevy::math::DMat4>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DMat4::project_point3(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn row(_self: Ref<bevy::math::DMat4>, index: usize) {
+        let output: Val<bevy::math::DVec4> = bevy::math::DMat4::row(&_self, index)
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::DMat4>, rhs: Val<bevy::math::DMat4>) {
+        let output: Val<bevy::math::DMat4> = <bevy::math::DMat4 as std::ops::Sub<
+            bevy::math::DMat4,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn sub_mat4(_self: Ref<bevy::math::DMat4>, rhs: Ref<bevy::math::DMat4>) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::sub_mat4(&_self, &rhs)
+            .into();
+        output
+    }
+    fn to_cols_array(_self: Ref<bevy::math::DMat4>) {
+        let output: [f64; 16] = bevy::math::DMat4::to_cols_array(&_self).into();
+        output
+    }
+    fn to_cols_array_2d(_self: Ref<bevy::math::DMat4>) {
+        let output: [[f64; 4]; 4] = bevy::math::DMat4::to_cols_array_2d(&_self).into();
+        output
+    }
+    fn to_euler(_self: Ref<bevy::math::DMat4>, order: Val<bevy::math::EulerRot>) {
+        let output: (f64, f64, f64) = bevy::math::DMat4::to_euler(
+                &_self,
+                order.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transform_point3(_self: Ref<bevy::math::DMat4>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DMat4::transform_point3(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transform_vector3(_self: Ref<bevy::math::DMat4>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DMat4::transform_vector3(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transpose(_self: Ref<bevy::math::DMat4>) {
+        let output: Val<bevy::math::DMat4> = bevy::math::DMat4::transpose(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "affine_2")]
+impl bevy::math::Affine2 {
+    fn abs_diff_eq(
+        _self: Ref<bevy::math::Affine2>,
+        rhs: Val<bevy::math::Affine2>,
+        max_abs_diff: f32,
+    ) {
+        let output: bool = bevy::math::Affine2::abs_diff_eq(
+                &_self,
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::Affine2>) {
+        let output: Val<bevy::math::Affine2> = <bevy::math::Affine2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::Affine2>, rhs: Ref<bevy::math::Affine2>) {
+        let output: bool = <bevy::math::Affine2 as std::cmp::PartialEq<
+            bevy::math::Affine2,
+        >>::eq(&_self, &rhs)
+            .into();
+        output
+    }
+    fn from_angle(angle: f32) {
+        let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_angle(angle)
+            .into();
+        output
+    }
+    fn from_angle_translation(angle: f32, translation: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_angle_translation(
+                angle,
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_cols(
+        x_axis: Val<bevy::math::Vec2>,
+        y_axis: Val<bevy::math::Vec2>,
+        z_axis: Val<bevy::math::Vec2>,
+    ) {
+        let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_cols(
+                x_axis.into_inner(),
+                y_axis.into_inner(),
+                z_axis.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_mat2(matrix2: Val<bevy::math::Mat2>) {
+        let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_mat2(
+                matrix2.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_mat2_translation(
+        matrix2: Val<bevy::math::Mat2>,
+        translation: Val<bevy::math::Vec2>,
+    ) {
+        let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_mat2_translation(
+                matrix2.into_inner(),
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_mat3(m: Val<bevy::math::Mat3>) {
+        let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_mat3(
+                m.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_mat3a(m: Val<bevy::math::Mat3A>) {
+        let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_mat3a(
+                m.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_scale(scale: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_scale(
+                scale.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_scale_angle_translation(
+        scale: Val<bevy::math::Vec2>,
+        angle: f32,
+        translation: Val<bevy::math::Vec2>,
+    ) {
+        let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_scale_angle_translation(
+                scale.into_inner(),
+                angle,
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_translation(translation: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_translation(
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn inverse(_self: Ref<bevy::math::Affine2>) {
+        let output: Val<bevy::math::Affine2> = bevy::math::Affine2::inverse(&_self)
+            .into();
+        output
+    }
+    fn is_finite(_self: Ref<bevy::math::Affine2>) {
+        let output: bool = bevy::math::Affine2::is_finite(&_self).into();
+        output
+    }
+    fn is_nan(_self: Ref<bevy::math::Affine2>) {
+        let output: bool = bevy::math::Affine2::is_nan(&_self).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Affine2>, rhs: Val<bevy::math::Affine2>) {
+        let output: Val<bevy::math::Affine2> = <bevy::math::Affine2 as std::ops::Mul<
+            bevy::math::Affine2,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Affine2>, rhs: Val<bevy::math::Mat3>) {
+        let output: Val<bevy::math::Mat3> = <bevy::math::Affine2 as std::ops::Mul<
+            bevy::math::Mat3,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Affine2>, rhs: Val<bevy::math::Mat3A>) {
+        let output: Val<bevy::math::Mat3A> = <bevy::math::Affine2 as std::ops::Mul<
+            bevy::math::Mat3A,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn to_cols_array(_self: Ref<bevy::math::Affine2>) {
+        let output: [f32; 6] = bevy::math::Affine2::to_cols_array(&_self).into();
+        output
+    }
+    fn to_cols_array_2d(_self: Ref<bevy::math::Affine2>) {
+        let output: [[f32; 2]; 3] = bevy::math::Affine2::to_cols_array_2d(&_self).into();
+        output
+    }
+    fn transform_point2(_self: Ref<bevy::math::Affine2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Affine2::transform_point2(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transform_vector2(_self: Ref<bevy::math::Affine2>, rhs: Val<bevy::math::Vec2>) {
+        let output: Val<bevy::math::Vec2> = bevy::math::Affine2::transform_vector2(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "affine_3_a")]
+impl bevy::math::Affine3A {
+    fn abs_diff_eq(
+        _self: Ref<bevy::math::Affine3A>,
+        rhs: Val<bevy::math::Affine3A>,
+        max_abs_diff: f32,
+    ) {
+        let output: bool = bevy::math::Affine3A::abs_diff_eq(
+                &_self,
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::Affine3A>) {
+        let output: Val<bevy::math::Affine3A> = <bevy::math::Affine3A as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::Affine3A>, rhs: Ref<bevy::math::Affine3A>) {
+        let output: bool = <bevy::math::Affine3A as std::cmp::PartialEq<
+            bevy::math::Affine3A,
+        >>::eq(&_self, &rhs)
+            .into();
+        output
+    }
+    fn from_axis_angle(axis: Val<bevy::math::Vec3>, angle: f32) {
+        let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_axis_angle(
+                axis.into_inner(),
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_cols(
+        x_axis: Val<bevy::math::Vec3A>,
+        y_axis: Val<bevy::math::Vec3A>,
+        z_axis: Val<bevy::math::Vec3A>,
+        w_axis: Val<bevy::math::Vec3A>,
+    ) {
+        let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_cols(
+                x_axis.into_inner(),
+                y_axis.into_inner(),
+                z_axis.into_inner(),
+                w_axis.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_mat3(mat3: Val<bevy::math::Mat3>) {
+        let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_mat3(
+                mat3.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_mat3_translation(
+        mat3: Val<bevy::math::Mat3>,
+        translation: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_mat3_translation(
+                mat3.into_inner(),
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_mat4(m: Val<bevy::math::Mat4>) {
+        let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_mat4(
+                m.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_quat(rotation: Val<bevy::math::Quat>) {
+        let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_quat(
+                rotation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_rotation_translation(
+        rotation: Val<bevy::math::Quat>,
+        translation: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_rotation_translation(
+                rotation.into_inner(),
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_rotation_x(angle: f32) {
+        let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_rotation_x(
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_rotation_y(angle: f32) {
+        let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_rotation_y(
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_rotation_z(angle: f32) {
+        let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_rotation_z(
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_scale(scale: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_scale(
+                scale.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_scale_rotation_translation(
+        scale: Val<bevy::math::Vec3>,
+        rotation: Val<bevy::math::Quat>,
+        translation: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_scale_rotation_translation(
+                scale.into_inner(),
+                rotation.into_inner(),
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_translation(translation: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_translation(
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn inverse(_self: Ref<bevy::math::Affine3A>) {
+        let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::inverse(&_self)
+            .into();
+        output
+    }
+    fn is_finite(_self: Ref<bevy::math::Affine3A>) {
+        let output: bool = bevy::math::Affine3A::is_finite(&_self).into();
+        output
+    }
+    fn is_nan(_self: Ref<bevy::math::Affine3A>) {
+        let output: bool = bevy::math::Affine3A::is_nan(&_self).into();
+        output
+    }
+    fn look_at_lh(
+        eye: Val<bevy::math::Vec3>,
+        center: Val<bevy::math::Vec3>,
+        up: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::look_at_lh(
+                eye.into_inner(),
+                center.into_inner(),
+                up.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn look_at_rh(
+        eye: Val<bevy::math::Vec3>,
+        center: Val<bevy::math::Vec3>,
+        up: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::look_at_rh(
+                eye.into_inner(),
+                center.into_inner(),
+                up.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn look_to_lh(
+        eye: Val<bevy::math::Vec3>,
+        dir: Val<bevy::math::Vec3>,
+        up: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::look_to_lh(
+                eye.into_inner(),
+                dir.into_inner(),
+                up.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn look_to_rh(
+        eye: Val<bevy::math::Vec3>,
+        dir: Val<bevy::math::Vec3>,
+        up: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::look_to_rh(
+                eye.into_inner(),
+                dir.into_inner(),
+                up.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Affine3A>, rhs: Val<bevy::math::Affine3A>) {
+        let output: Val<bevy::math::Affine3A> = <bevy::math::Affine3A as std::ops::Mul<
+            bevy::math::Affine3A,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::Affine3A>, rhs: Val<bevy::math::Mat4>) {
+        let output: Val<bevy::math::Mat4> = <bevy::math::Affine3A as std::ops::Mul<
+            bevy::math::Mat4,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn to_cols_array(_self: Ref<bevy::math::Affine3A>) {
+        let output: [f32; 12] = bevy::math::Affine3A::to_cols_array(&_self).into();
+        output
+    }
+    fn to_cols_array_2d(_self: Ref<bevy::math::Affine3A>) {
+        let output: [[f32; 3]; 4] = bevy::math::Affine3A::to_cols_array_2d(&_self)
+            .into();
+        output
+    }
+    fn transform_point3(_self: Ref<bevy::math::Affine3A>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Affine3A::transform_point3(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transform_point3a(_self: Ref<bevy::math::Affine3A>, rhs: Val<bevy::math::Vec3A>) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Affine3A::transform_point3a(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transform_vector3(_self: Ref<bevy::math::Affine3A>, rhs: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::math::Vec3> = bevy::math::Affine3A::transform_vector3(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transform_vector3a(
+        _self: Ref<bevy::math::Affine3A>,
+        rhs: Val<bevy::math::Vec3A>,
+    ) {
+        let output: Val<bevy::math::Vec3A> = bevy::math::Affine3A::transform_vector3a(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "d_affine_2")]
+impl bevy::math::DAffine2 {
+    fn abs_diff_eq(
+        _self: Ref<bevy::math::DAffine2>,
+        rhs: Val<bevy::math::DAffine2>,
+        max_abs_diff: f64,
+    ) {
+        let output: bool = bevy::math::DAffine2::abs_diff_eq(
+                &_self,
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::DAffine2>) {
+        let output: Val<bevy::math::DAffine2> = <bevy::math::DAffine2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::DAffine2>, rhs: Ref<bevy::math::DAffine2>) {
+        let output: bool = <bevy::math::DAffine2 as std::cmp::PartialEq<
+            bevy::math::DAffine2,
+        >>::eq(&_self, &rhs)
+            .into();
+        output
+    }
+    fn from_angle(angle: f64) {
+        let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::from_angle(angle)
+            .into();
+        output
+    }
+    fn from_angle_translation(angle: f64, translation: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::from_angle_translation(
+                angle,
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_cols(
+        x_axis: Val<bevy::math::DVec2>,
+        y_axis: Val<bevy::math::DVec2>,
+        z_axis: Val<bevy::math::DVec2>,
+    ) {
+        let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::from_cols(
+                x_axis.into_inner(),
+                y_axis.into_inner(),
+                z_axis.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_mat2(matrix2: Val<bevy::math::DMat2>) {
+        let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::from_mat2(
+                matrix2.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_mat2_translation(
+        matrix2: Val<bevy::math::DMat2>,
+        translation: Val<bevy::math::DVec2>,
+    ) {
+        let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::from_mat2_translation(
+                matrix2.into_inner(),
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_mat3(m: Val<bevy::math::DMat3>) {
+        let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::from_mat3(
+                m.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_scale(scale: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::from_scale(
+                scale.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_scale_angle_translation(
+        scale: Val<bevy::math::DVec2>,
+        angle: f64,
+        translation: Val<bevy::math::DVec2>,
+    ) {
+        let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::from_scale_angle_translation(
+                scale.into_inner(),
+                angle,
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_translation(translation: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::from_translation(
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn inverse(_self: Ref<bevy::math::DAffine2>) {
+        let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::inverse(&_self)
+            .into();
+        output
+    }
+    fn is_finite(_self: Ref<bevy::math::DAffine2>) {
+        let output: bool = bevy::math::DAffine2::is_finite(&_self).into();
+        output
+    }
+    fn is_nan(_self: Ref<bevy::math::DAffine2>) {
+        let output: bool = bevy::math::DAffine2::is_nan(&_self).into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DAffine2>, rhs: Val<bevy::math::DAffine2>) {
+        let output: Val<bevy::math::DAffine2> = <bevy::math::DAffine2 as std::ops::Mul<
+            bevy::math::DAffine2,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DAffine2>, rhs: Val<bevy::math::DMat3>) {
+        let output: Val<bevy::math::DMat3> = <bevy::math::DAffine2 as std::ops::Mul<
+            bevy::math::DMat3,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn to_cols_array(_self: Ref<bevy::math::DAffine2>) {
+        let output: [f64; 6] = bevy::math::DAffine2::to_cols_array(&_self).into();
+        output
+    }
+    fn to_cols_array_2d(_self: Ref<bevy::math::DAffine2>) {
+        let output: [[f64; 2]; 3] = bevy::math::DAffine2::to_cols_array_2d(&_self)
+            .into();
+        output
+    }
+    fn transform_point2(_self: Ref<bevy::math::DAffine2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DAffine2::transform_point2(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transform_vector2(_self: Ref<bevy::math::DAffine2>, rhs: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DVec2> = bevy::math::DAffine2::transform_vector2(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "d_affine_3")]
+impl bevy::math::DAffine3 {
+    fn abs_diff_eq(
+        _self: Ref<bevy::math::DAffine3>,
+        rhs: Val<bevy::math::DAffine3>,
+        max_abs_diff: f64,
+    ) {
+        let output: bool = bevy::math::DAffine3::abs_diff_eq(
+                &_self,
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::DAffine3>) {
+        let output: Val<bevy::math::DAffine3> = <bevy::math::DAffine3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::DAffine3>, rhs: Ref<bevy::math::DAffine3>) {
+        let output: bool = <bevy::math::DAffine3 as std::cmp::PartialEq<
+            bevy::math::DAffine3,
+        >>::eq(&_self, &rhs)
+            .into();
+        output
+    }
+    fn from_axis_angle(axis: Val<bevy::math::DVec3>, angle: f64) {
+        let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_axis_angle(
+                axis.into_inner(),
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_cols(
+        x_axis: Val<bevy::math::DVec3>,
+        y_axis: Val<bevy::math::DVec3>,
+        z_axis: Val<bevy::math::DVec3>,
+        w_axis: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_cols(
+                x_axis.into_inner(),
+                y_axis.into_inner(),
+                z_axis.into_inner(),
+                w_axis.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_mat3(mat3: Val<bevy::math::DMat3>) {
+        let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_mat3(
+                mat3.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_mat3_translation(
+        mat3: Val<bevy::math::DMat3>,
+        translation: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_mat3_translation(
+                mat3.into_inner(),
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_mat4(m: Val<bevy::math::DMat4>) {
+        let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_mat4(
+                m.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_quat(rotation: Val<bevy::math::DQuat>) {
+        let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_quat(
+                rotation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_rotation_translation(
+        rotation: Val<bevy::math::DQuat>,
+        translation: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_rotation_translation(
+                rotation.into_inner(),
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_rotation_x(angle: f64) {
+        let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_rotation_x(
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_rotation_y(angle: f64) {
+        let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_rotation_y(
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_rotation_z(angle: f64) {
+        let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_rotation_z(
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_scale(scale: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_scale(
+                scale.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_scale_rotation_translation(
+        scale: Val<bevy::math::DVec3>,
+        rotation: Val<bevy::math::DQuat>,
+        translation: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_scale_rotation_translation(
+                scale.into_inner(),
+                rotation.into_inner(),
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_translation(translation: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_translation(
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn inverse(_self: Ref<bevy::math::DAffine3>) {
+        let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::inverse(&_self)
+            .into();
+        output
+    }
+    fn is_finite(_self: Ref<bevy::math::DAffine3>) {
+        let output: bool = bevy::math::DAffine3::is_finite(&_self).into();
+        output
+    }
+    fn is_nan(_self: Ref<bevy::math::DAffine3>) {
+        let output: bool = bevy::math::DAffine3::is_nan(&_self).into();
+        output
+    }
+    fn look_at_lh(
+        eye: Val<bevy::math::DVec3>,
+        center: Val<bevy::math::DVec3>,
+        up: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::look_at_lh(
+                eye.into_inner(),
+                center.into_inner(),
+                up.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn look_at_rh(
+        eye: Val<bevy::math::DVec3>,
+        center: Val<bevy::math::DVec3>,
+        up: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::look_at_rh(
+                eye.into_inner(),
+                center.into_inner(),
+                up.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn look_to_lh(
+        eye: Val<bevy::math::DVec3>,
+        dir: Val<bevy::math::DVec3>,
+        up: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::look_to_lh(
+                eye.into_inner(),
+                dir.into_inner(),
+                up.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn look_to_rh(
+        eye: Val<bevy::math::DVec3>,
+        dir: Val<bevy::math::DVec3>,
+        up: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::look_to_rh(
+                eye.into_inner(),
+                dir.into_inner(),
+                up.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DAffine3>, rhs: Val<bevy::math::DAffine3>) {
+        let output: Val<bevy::math::DAffine3> = <bevy::math::DAffine3 as std::ops::Mul<
+            bevy::math::DAffine3,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DAffine3>, rhs: Val<bevy::math::DMat4>) {
+        let output: Val<bevy::math::DMat4> = <bevy::math::DAffine3 as std::ops::Mul<
+            bevy::math::DMat4,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn to_cols_array(_self: Ref<bevy::math::DAffine3>) {
+        let output: [f64; 12] = bevy::math::DAffine3::to_cols_array(&_self).into();
+        output
+    }
+    fn to_cols_array_2d(_self: Ref<bevy::math::DAffine3>) {
+        let output: [[f64; 3]; 4] = bevy::math::DAffine3::to_cols_array_2d(&_self)
+            .into();
+        output
+    }
+    fn transform_point3(_self: Ref<bevy::math::DAffine3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DAffine3::transform_point3(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn transform_vector3(_self: Ref<bevy::math::DAffine3>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DAffine3::transform_vector3(
+                &_self,
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "d_quat")]
+impl bevy::math::DQuat {
+    fn abs_diff_eq(
+        _self: Val<bevy::math::DQuat>,
+        rhs: Val<bevy::math::DQuat>,
+        max_abs_diff: f64,
+    ) {
+        let output: bool = bevy::math::DQuat::abs_diff_eq(
+                _self.into_inner(),
+                rhs.into_inner(),
+                max_abs_diff,
+            )
+            .into();
+        output
+    }
+    fn add(_self: Val<bevy::math::DQuat>, rhs: Val<bevy::math::DQuat>) {
+        let output: Val<bevy::math::DQuat> = <bevy::math::DQuat as std::ops::Add<
+            bevy::math::DQuat,
+        >>::add(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn angle_between(_self: Val<bevy::math::DQuat>, rhs: Val<bevy::math::DQuat>) {
+        let output: f64 = bevy::math::DQuat::angle_between(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn as_quat(_self: Val<bevy::math::DQuat>) {
+        let output: Val<bevy::math::Quat> = bevy::math::DQuat::as_quat(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::DQuat>) {
+        let output: Val<bevy::math::DQuat> = <bevy::math::DQuat as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn conjugate(_self: Val<bevy::math::DQuat>) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::conjugate(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn div(_self: Val<bevy::math::DQuat>, rhs: f64) {
+        let output: Val<bevy::math::DQuat> = <bevy::math::DQuat as std::ops::Div<
+            f64,
+        >>::div(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn dot(_self: Val<bevy::math::DQuat>, rhs: Val<bevy::math::DQuat>) {
+        let output: f64 = bevy::math::DQuat::dot(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::DQuat>, rhs: Ref<bevy::math::DQuat>) {
+        let output: bool = <bevy::math::DQuat as std::cmp::PartialEq<
+            bevy::math::DQuat,
+        >>::eq(&_self, &rhs)
+            .into();
+        output
+    }
+    fn from_affine3(a: Ref<bevy::math::DAffine3>) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_affine3(&a).into();
+        output
+    }
+    fn from_array(a: [f64; 4]) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_array(a).into();
+        output
+    }
+    fn from_axis_angle(axis: Val<bevy::math::DVec3>, angle: f64) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_axis_angle(
+                axis.into_inner(),
+                angle,
+            )
+            .into();
+        output
+    }
+    fn from_euler(euler: Val<bevy::math::EulerRot>, a: f64, b: f64, c: f64) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_euler(
+                euler.into_inner(),
+                a,
+                b,
+                c,
+            )
+            .into();
+        output
+    }
+    fn from_mat3(mat: Ref<bevy::math::DMat3>) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_mat3(&mat).into();
+        output
+    }
+    fn from_mat4(mat: Ref<bevy::math::DMat4>) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_mat4(&mat).into();
+        output
+    }
+    fn from_rotation_arc(from: Val<bevy::math::DVec3>, to: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_rotation_arc(
+                from.into_inner(),
+                to.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_rotation_arc_2d(from: Val<bevy::math::DVec2>, to: Val<bevy::math::DVec2>) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_rotation_arc_2d(
+                from.into_inner(),
+                to.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_rotation_arc_colinear(
+        from: Val<bevy::math::DVec3>,
+        to: Val<bevy::math::DVec3>,
+    ) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_rotation_arc_colinear(
+                from.into_inner(),
+                to.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_rotation_x(angle: f64) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_rotation_x(angle)
+            .into();
+        output
+    }
+    fn from_rotation_y(angle: f64) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_rotation_y(angle)
+            .into();
+        output
+    }
+    fn from_rotation_z(angle: f64) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_rotation_z(angle)
+            .into();
+        output
+    }
+    fn from_scaled_axis(v: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_scaled_axis(
+                v.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_vec4(v: Val<bevy::math::DVec4>) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_vec4(v.into_inner())
+            .into();
+        output
+    }
+    fn from_xyzw(x: f64, y: f64, z: f64, w: f64) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_xyzw(x, y, z, w)
+            .into();
+        output
+    }
+    fn inverse(_self: Val<bevy::math::DQuat>) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::inverse(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn is_finite(_self: Val<bevy::math::DQuat>) {
+        let output: bool = bevy::math::DQuat::is_finite(_self.into_inner()).into();
+        output
+    }
+    fn is_nan(_self: Val<bevy::math::DQuat>) {
+        let output: bool = bevy::math::DQuat::is_nan(_self.into_inner()).into();
+        output
+    }
+    fn is_near_identity(_self: Val<bevy::math::DQuat>) {
+        let output: bool = bevy::math::DQuat::is_near_identity(_self.into_inner())
+            .into();
+        output
+    }
+    fn is_normalized(_self: Val<bevy::math::DQuat>) {
+        let output: bool = bevy::math::DQuat::is_normalized(_self.into_inner()).into();
+        output
+    }
+    fn length(_self: Val<bevy::math::DQuat>) {
+        let output: f64 = bevy::math::DQuat::length(_self.into_inner()).into();
+        output
+    }
+    fn length_recip(_self: Val<bevy::math::DQuat>) {
+        let output: f64 = bevy::math::DQuat::length_recip(_self.into_inner()).into();
+        output
+    }
+    fn length_squared(_self: Val<bevy::math::DQuat>) {
+        let output: f64 = bevy::math::DQuat::length_squared(_self.into_inner()).into();
+        output
+    }
+    fn lerp(_self: Val<bevy::math::DQuat>, end: Val<bevy::math::DQuat>, s: f64) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::lerp(
+                _self.into_inner(),
+                end.into_inner(),
+                s,
+            )
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DQuat>, rhs: Val<bevy::math::DQuat>) {
+        let output: Val<bevy::math::DQuat> = <bevy::math::DQuat as std::ops::Mul<
+            bevy::math::DQuat,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DQuat>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = <bevy::math::DQuat as std::ops::Mul<
+            bevy::math::DVec3,
+        >>::mul(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn mul(_self: Val<bevy::math::DQuat>, rhs: f64) {
+        let output: Val<bevy::math::DQuat> = <bevy::math::DQuat as std::ops::Mul<
+            f64,
+        >>::mul(_self.into_inner(), rhs)
+            .into();
+        output
+    }
+    fn mul_quat(_self: Val<bevy::math::DQuat>, rhs: Val<bevy::math::DQuat>) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::mul_quat(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn mul_vec3(_self: Val<bevy::math::DQuat>, rhs: Val<bevy::math::DVec3>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DQuat::mul_vec3(
+                _self.into_inner(),
+                rhs.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn neg(_self: Val<bevy::math::DQuat>) {
+        let output: Val<bevy::math::DQuat> = <bevy::math::DQuat as std::ops::Neg>::neg(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn normalize(_self: Val<bevy::math::DQuat>) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::normalize(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rotate_towards(
+        _self: Ref<bevy::math::DQuat>,
+        rhs: Val<bevy::math::DQuat>,
+        max_angle: f64,
+    ) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::rotate_towards(
+                &_self,
+                rhs.into_inner(),
+                max_angle,
+            )
+            .into();
+        output
+    }
+    fn slerp(_self: Val<bevy::math::DQuat>, end: Val<bevy::math::DQuat>, s: f64) {
+        let output: Val<bevy::math::DQuat> = bevy::math::DQuat::slerp(
+                _self.into_inner(),
+                end.into_inner(),
+                s,
+            )
+            .into();
+        output
+    }
+    fn sub(_self: Val<bevy::math::DQuat>, rhs: Val<bevy::math::DQuat>) {
+        let output: Val<bevy::math::DQuat> = <bevy::math::DQuat as std::ops::Sub<
+            bevy::math::DQuat,
+        >>::sub(_self.into_inner(), rhs.into_inner())
+            .into();
+        output
+    }
+    fn to_array(_self: Ref<bevy::math::DQuat>) {
+        let output: [f64; 4] = bevy::math::DQuat::to_array(&_self).into();
+        output
+    }
+    fn to_euler(_self: Val<bevy::math::DQuat>, order: Val<bevy::math::EulerRot>) {
+        let output: (f64, f64, f64) = bevy::math::DQuat::to_euler(
+                _self.into_inner(),
+                order.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn to_scaled_axis(_self: Val<bevy::math::DQuat>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DQuat::to_scaled_axis(
+                _self.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn xyz(_self: Val<bevy::math::DQuat>) {
+        let output: Val<bevy::math::DVec3> = bevy::math::DQuat::xyz(_self.into_inner())
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "euler_rot")]
+impl bevy::math::EulerRot {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::math::EulerRot>) {
+        let output: () = <bevy::math::EulerRot as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::EulerRot>) {
+        let output: Val<bevy::math::EulerRot> = <bevy::math::EulerRot as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::EulerRot>, other: Ref<bevy::math::EulerRot>) {
+        let output: bool = <bevy::math::EulerRot as std::cmp::PartialEq<
+            bevy::math::EulerRot,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "b_vec_3_a")]
+impl bevy::math::BVec3A {
+    fn all(_self: Val<bevy::math::BVec3A>) {
+        let output: bool = bevy::math::BVec3A::all(_self.into_inner()).into();
+        output
+    }
+    fn any(_self: Val<bevy::math::BVec3A>) {
+        let output: bool = bevy::math::BVec3A::any(_self.into_inner()).into();
+        output
+    }
+    fn bitmask(_self: Val<bevy::math::BVec3A>) {
+        let output: u32 = bevy::math::BVec3A::bitmask(_self.into_inner()).into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::BVec3A>) {
+        let output: Val<bevy::math::BVec3A> = <bevy::math::BVec3A as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::BVec3A>, rhs: Ref<bevy::math::BVec3A>) {
+        let output: bool = <bevy::math::BVec3A as std::cmp::PartialEq<
+            bevy::math::BVec3A,
+        >>::eq(&_self, &rhs)
+            .into();
+        output
+    }
+    fn from_array(a: [bool; 3]) {
+        let output: Val<bevy::math::BVec3A> = bevy::math::BVec3A::from_array(a).into();
+        output
+    }
+    fn new(x: bool, y: bool, z: bool) {
+        let output: Val<bevy::math::BVec3A> = bevy::math::BVec3A::new(x, y, z).into();
+        output
+    }
+    fn set(mut _self: Mut<bevy::math::BVec3A>, index: usize, value: bool) {
+        let output: () = bevy::math::BVec3A::set(&mut _self, index, value).into();
+        output
+    }
+    fn splat(v: bool) {
+        let output: Val<bevy::math::BVec3A> = bevy::math::BVec3A::splat(v).into();
+        output
+    }
+    fn test(_self: Ref<bevy::math::BVec3A>, index: usize) {
+        let output: bool = bevy::math::BVec3A::test(&_self, index).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "b_vec_4_a")]
+impl bevy::math::BVec4A {
+    fn all(_self: Val<bevy::math::BVec4A>) {
+        let output: bool = bevy::math::BVec4A::all(_self.into_inner()).into();
+        output
+    }
+    fn any(_self: Val<bevy::math::BVec4A>) {
+        let output: bool = bevy::math::BVec4A::any(_self.into_inner()).into();
+        output
+    }
+    fn bitmask(_self: Val<bevy::math::BVec4A>) {
+        let output: u32 = bevy::math::BVec4A::bitmask(_self.into_inner()).into();
+        output
+    }
+    fn clone(_self: Ref<bevy::math::BVec4A>) {
+        let output: Val<bevy::math::BVec4A> = <bevy::math::BVec4A as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<bevy::math::BVec4A>, rhs: Ref<bevy::math::BVec4A>) {
+        let output: bool = <bevy::math::BVec4A as std::cmp::PartialEq<
+            bevy::math::BVec4A,
+        >>::eq(&_self, &rhs)
+            .into();
+        output
+    }
+    fn from_array(a: [bool; 4]) {
+        let output: Val<bevy::math::BVec4A> = bevy::math::BVec4A::from_array(a).into();
+        output
+    }
+    fn new(x: bool, y: bool, z: bool, w: bool) {
+        let output: Val<bevy::math::BVec4A> = bevy::math::BVec4A::new(x, y, z, w).into();
+        output
+    }
+    fn set(mut _self: Mut<bevy::math::BVec4A>, index: usize, value: bool) {
+        let output: () = bevy::math::BVec4A::set(&mut _self, index, value).into();
+        output
+    }
+    fn splat(v: bool) {
+        let output: Val<bevy::math::BVec4A> = bevy::math::BVec4A::splat(v).into();
+        output
+    }
+    fn test(_self: Ref<bevy::math::BVec4A>, index: usize) {
+        let output: bool = bevy::math::BVec4A::test(&_self, index).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "smol_str")]
+impl smol_str::SmolStr {
+    fn clone(_self: Ref<smol_str::SmolStr>) {
+        let output: Val<smol_str::SmolStr> = <smol_str::SmolStr as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(_self: Ref<smol_str::SmolStr>, other: Ref<smol_str::SmolStr>) {
+        let output: bool = <smol_str::SmolStr as std::cmp::PartialEq<
+            smol_str::SmolStr,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn is_empty(_self: Ref<smol_str::SmolStr>) {
+        let output: bool = smol_str::SmolStr::is_empty(&_self).into();
+        output
+    }
+    fn is_heap_allocated(_self: Ref<smol_str::SmolStr>) {
+        let output: bool = smol_str::SmolStr::is_heap_allocated(&_self).into();
+        output
+    }
+    fn len(_self: Ref<smol_str::SmolStr>) {
+        let output: usize = smol_str::SmolStr::len(&_self).into();
+        output
+    }
+    fn to_string(_self: Ref<smol_str::SmolStr>) {
+        let output: std::string::String = smol_str::SmolStr::to_string(&_self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "uuid")]
+impl uuid::Uuid {
+    fn as_u128(_self: Ref<uuid::Uuid>) {
+        let output: u128 = uuid::Uuid::as_u128(&_self).into();
+        output
+    }
+    fn as_u64_pair(_self: Ref<uuid::Uuid>) {
+        let output: (u64, u64) = uuid::Uuid::as_u64_pair(&_self).into();
+        output
+    }
+    fn assert_receiver_is_total_eq(_self: Ref<uuid::Uuid>) {
+        let output: () = <uuid::Uuid as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<uuid::Uuid>) {
+        let output: Val<uuid::Uuid> = <uuid::Uuid as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn encode_buffer() {
+        let output: [u8; 45] = uuid::Uuid::encode_buffer().into();
+        output
+    }
+    fn eq(_self: Ref<uuid::Uuid>, other: Ref<uuid::Uuid>) {
+        let output: bool = <uuid::Uuid as std::cmp::PartialEq<
+            uuid::Uuid,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn from_bytes(bytes: [u8; 16]) {
+        let output: Val<uuid::Uuid> = uuid::Uuid::from_bytes(bytes).into();
+        output
+    }
+    fn from_bytes_le(b: [u8; 16]) {
+        let output: Val<uuid::Uuid> = uuid::Uuid::from_bytes_le(b).into();
+        output
+    }
+    fn from_u128(v: u128) {
+        let output: Val<uuid::Uuid> = uuid::Uuid::from_u128(v).into();
+        output
+    }
+    fn from_u128_le(v: u128) {
+        let output: Val<uuid::Uuid> = uuid::Uuid::from_u128_le(v).into();
+        output
+    }
+    fn from_u64_pair(high_bits: u64, low_bits: u64) {
+        let output: Val<uuid::Uuid> = uuid::Uuid::from_u64_pair(high_bits, low_bits)
+            .into();
+        output
+    }
+    fn get_node_id(_self: Ref<uuid::Uuid>) {
+        let output: bevy::reflect::erased_serde::__private::serde::__private::Option<
+            [u8; 6],
+        > = uuid::Uuid::get_node_id(&_self).into();
+        output
+    }
+    fn get_version_num(_self: Ref<uuid::Uuid>) {
+        let output: usize = uuid::Uuid::get_version_num(&_self).into();
+        output
+    }
+    fn into_bytes(_self: Val<uuid::Uuid>) {
+        let output: [u8; 16] = uuid::Uuid::into_bytes(_self.into_inner()).into();
+        output
+    }
+    fn is_max(_self: Ref<uuid::Uuid>) {
+        let output: bool = uuid::Uuid::is_max(&_self).into();
+        output
+    }
+    fn is_nil(_self: Ref<uuid::Uuid>) {
+        let output: bool = uuid::Uuid::is_nil(&_self).into();
+        output
+    }
+    fn max() {
+        let output: Val<uuid::Uuid> = uuid::Uuid::max().into();
+        output
+    }
+    fn new_v4() {
+        let output: Val<uuid::Uuid> = uuid::Uuid::new_v4().into();
+        output
+    }
+    fn nil() {
+        let output: Val<uuid::Uuid> = uuid::Uuid::nil().into();
+        output
+    }
+    fn to_bytes_le(_self: Ref<uuid::Uuid>) {
+        let output: [u8; 16] = uuid::Uuid::to_bytes_le(&_self).into();
+        output
+    }
+    fn to_u128_le(_self: Ref<uuid::Uuid>) {
+        let output: u128 = uuid::Uuid::to_u128_le(&_self).into();
+        output
+    }
+}
 impl ::bevy::app::Plugin for BevyReflectScriptingPlugin {
     fn build(&self, app: &mut ::bevy::prelude::App) {
         let mut world = app.world_mut();
-        NamespaceBuilder::<::std::sync::atomic::AtomicBool>::new(world)
-            .register(
-                "into_inner",
-                |_self: Val<std::sync::atomic::AtomicBool>| {
-                    let output: bool = std::sync::atomic::AtomicBool::into_inner(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |v: bool| {
-                    let output: Val<std::sync::atomic::AtomicBool> = std::sync::atomic::AtomicBool::new(
-                            v,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::std::sync::atomic::AtomicI16>::new(world)
-            .register(
-                "into_inner",
-                |_self: Val<std::sync::atomic::AtomicI16>| {
-                    let output: i16 = std::sync::atomic::AtomicI16::into_inner(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |v: i16| {
-                    let output: Val<std::sync::atomic::AtomicI16> = std::sync::atomic::AtomicI16::new(
-                            v,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::std::sync::atomic::AtomicI32>::new(world)
-            .register(
-                "into_inner",
-                |_self: Val<std::sync::atomic::AtomicI32>| {
-                    let output: i32 = std::sync::atomic::AtomicI32::into_inner(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |v: i32| {
-                    let output: Val<std::sync::atomic::AtomicI32> = std::sync::atomic::AtomicI32::new(
-                            v,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::std::sync::atomic::AtomicI64>::new(world)
-            .register(
-                "into_inner",
-                |_self: Val<std::sync::atomic::AtomicI64>| {
-                    let output: i64 = std::sync::atomic::AtomicI64::into_inner(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |v: i64| {
-                    let output: Val<std::sync::atomic::AtomicI64> = std::sync::atomic::AtomicI64::new(
-                            v,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::std::sync::atomic::AtomicI8>::new(world)
-            .register(
-                "into_inner",
-                |_self: Val<std::sync::atomic::AtomicI8>| {
-                    let output: i8 = std::sync::atomic::AtomicI8::into_inner(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |v: i8| {
-                    let output: Val<std::sync::atomic::AtomicI8> = std::sync::atomic::AtomicI8::new(
-                            v,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::std::sync::atomic::AtomicIsize>::new(world)
-            .register(
-                "into_inner",
-                |_self: Val<std::sync::atomic::AtomicIsize>| {
-                    let output: isize = std::sync::atomic::AtomicIsize::into_inner(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |v: isize| {
-                    let output: Val<std::sync::atomic::AtomicIsize> = std::sync::atomic::AtomicIsize::new(
-                            v,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::std::sync::atomic::AtomicU16>::new(world)
-            .register(
-                "into_inner",
-                |_self: Val<std::sync::atomic::AtomicU16>| {
-                    let output: u16 = std::sync::atomic::AtomicU16::into_inner(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |v: u16| {
-                    let output: Val<std::sync::atomic::AtomicU16> = std::sync::atomic::AtomicU16::new(
-                            v,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::std::sync::atomic::AtomicU32>::new(world)
-            .register(
-                "into_inner",
-                |_self: Val<std::sync::atomic::AtomicU32>| {
-                    let output: u32 = std::sync::atomic::AtomicU32::into_inner(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |v: u32| {
-                    let output: Val<std::sync::atomic::AtomicU32> = std::sync::atomic::AtomicU32::new(
-                            v,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::std::sync::atomic::AtomicU64>::new(world)
-            .register(
-                "into_inner",
-                |_self: Val<std::sync::atomic::AtomicU64>| {
-                    let output: u64 = std::sync::atomic::AtomicU64::into_inner(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |v: u64| {
-                    let output: Val<std::sync::atomic::AtomicU64> = std::sync::atomic::AtomicU64::new(
-                            v,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::std::sync::atomic::AtomicU8>::new(world)
-            .register(
-                "into_inner",
-                |_self: Val<std::sync::atomic::AtomicU8>| {
-                    let output: u8 = std::sync::atomic::AtomicU8::into_inner(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |v: u8| {
-                    let output: Val<std::sync::atomic::AtomicU8> = std::sync::atomic::AtomicU8::new(
-                            v,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::std::sync::atomic::AtomicUsize>::new(world)
-            .register(
-                "into_inner",
-                |_self: Val<std::sync::atomic::AtomicUsize>| {
-                    let output: usize = std::sync::atomic::AtomicUsize::into_inner(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |v: usize| {
-                    let output: Val<std::sync::atomic::AtomicUsize> = std::sync::atomic::AtomicUsize::new(
-                            v,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::utils::Duration>::new(world)
-            .register(
-                "abs_diff",
-                |_self: Val<bevy::utils::Duration>, other: Val<bevy::utils::Duration>| {
-                    let output: Val<bevy::utils::Duration> = bevy::utils::Duration::abs_diff(
-                            _self.into_inner(),
-                            other.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::utils::Duration>, rhs: Val<bevy::utils::Duration>| {
-                    let output: Val<bevy::utils::Duration> = <bevy::utils::Duration as std::ops::Add<
-                        bevy::utils::Duration,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_micros",
-                |_self: Ref<bevy::utils::Duration>| {
-                    let output: u128 = bevy::utils::Duration::as_micros(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "as_millis",
-                |_self: Ref<bevy::utils::Duration>| {
-                    let output: u128 = bevy::utils::Duration::as_millis(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "as_nanos",
-                |_self: Ref<bevy::utils::Duration>| {
-                    let output: u128 = bevy::utils::Duration::as_nanos(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "as_secs",
-                |_self: Ref<bevy::utils::Duration>| {
-                    let output: u64 = bevy::utils::Duration::as_secs(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "as_secs_f32",
-                |_self: Ref<bevy::utils::Duration>| {
-                    let output: f32 = bevy::utils::Duration::as_secs_f32(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "as_secs_f64",
-                |_self: Ref<bevy::utils::Duration>| {
-                    let output: f64 = bevy::utils::Duration::as_secs_f64(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::utils::Duration>| {
-                    let output: () = <bevy::utils::Duration as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::utils::Duration>| {
-                    let output: Val<bevy::utils::Duration> = <bevy::utils::Duration as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::utils::Duration>, rhs: u32| {
-                    let output: Val<bevy::utils::Duration> = <bevy::utils::Duration as std::ops::Div<
-                        u32,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_duration_f32",
-                |_self: Val<bevy::utils::Duration>, rhs: Val<bevy::utils::Duration>| {
-                    let output: f32 = bevy::utils::Duration::div_duration_f32(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_duration_f64",
-                |_self: Val<bevy::utils::Duration>, rhs: Val<bevy::utils::Duration>| {
-                    let output: f64 = bevy::utils::Duration::div_duration_f64(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_f32",
-                |_self: Val<bevy::utils::Duration>, rhs: f32| {
-                    let output: Val<bevy::utils::Duration> = bevy::utils::Duration::div_f32(
-                            _self.into_inner(),
-                            rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_f64",
-                |_self: Val<bevy::utils::Duration>, rhs: f64| {
-                    let output: Val<bevy::utils::Duration> = bevy::utils::Duration::div_f64(
-                            _self.into_inner(),
-                            rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::utils::Duration>, other: Ref<bevy::utils::Duration>| {
-                    let output: bool = <bevy::utils::Duration as std::cmp::PartialEq<
-                        bevy::utils::Duration,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_micros",
-                |micros: u64| {
-                    let output: Val<bevy::utils::Duration> = bevy::utils::Duration::from_micros(
-                            micros,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_millis",
-                |millis: u64| {
-                    let output: Val<bevy::utils::Duration> = bevy::utils::Duration::from_millis(
-                            millis,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_nanos",
-                |nanos: u64| {
-                    let output: Val<bevy::utils::Duration> = bevy::utils::Duration::from_nanos(
-                            nanos,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_secs",
-                |secs: u64| {
-                    let output: Val<bevy::utils::Duration> = bevy::utils::Duration::from_secs(
-                            secs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_secs_f32",
-                |secs: f32| {
-                    let output: Val<bevy::utils::Duration> = bevy::utils::Duration::from_secs_f32(
-                            secs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_secs_f64",
-                |secs: f64| {
-                    let output: Val<bevy::utils::Duration> = bevy::utils::Duration::from_secs_f64(
-                            secs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_zero",
-                |_self: Ref<bevy::utils::Duration>| {
-                    let output: bool = bevy::utils::Duration::is_zero(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::utils::Duration>, rhs: u32| {
-                    let output: Val<bevy::utils::Duration> = <bevy::utils::Duration as std::ops::Mul<
-                        u32,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_f32",
-                |_self: Val<bevy::utils::Duration>, rhs: f32| {
-                    let output: Val<bevy::utils::Duration> = bevy::utils::Duration::mul_f32(
-                            _self.into_inner(),
-                            rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_f64",
-                |_self: Val<bevy::utils::Duration>, rhs: f64| {
-                    let output: Val<bevy::utils::Duration> = bevy::utils::Duration::mul_f64(
-                            _self.into_inner(),
-                            rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |secs: u64, nanos: u32| {
-                    let output: Val<bevy::utils::Duration> = bevy::utils::Duration::new(
-                            secs,
-                            nanos,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add",
-                |_self: Val<bevy::utils::Duration>, rhs: Val<bevy::utils::Duration>| {
-                    let output: Val<bevy::utils::Duration> = bevy::utils::Duration::saturating_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_mul",
-                |_self: Val<bevy::utils::Duration>, rhs: u32| {
-                    let output: Val<bevy::utils::Duration> = bevy::utils::Duration::saturating_mul(
-                            _self.into_inner(),
-                            rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_sub",
-                |_self: Val<bevy::utils::Duration>, rhs: Val<bevy::utils::Duration>| {
-                    let output: Val<bevy::utils::Duration> = bevy::utils::Duration::saturating_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::utils::Duration>, rhs: Val<bevy::utils::Duration>| {
-                    let output: Val<bevy::utils::Duration> = <bevy::utils::Duration as std::ops::Sub<
-                        bevy::utils::Duration,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "subsec_micros",
-                |_self: Ref<bevy::utils::Duration>| {
-                    let output: u32 = bevy::utils::Duration::subsec_micros(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "subsec_millis",
-                |_self: Ref<bevy::utils::Duration>| {
-                    let output: u32 = bevy::utils::Duration::subsec_millis(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "subsec_nanos",
-                |_self: Ref<bevy::utils::Duration>| {
-                    let output: u32 = bevy::utils::Duration::subsec_nanos(&_self).into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::utils::Instant>::new(world)
-            .register(
-                "add",
-                |_self: Val<bevy::utils::Instant>, other: Val<bevy::utils::Duration>| {
-                    let output: Val<bevy::utils::Instant> = <bevy::utils::Instant as std::ops::Add<
-                        bevy::utils::Duration,
-                    >>::add(_self.into_inner(), other.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::utils::Instant>| {
-                    let output: () = <bevy::utils::Instant as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::utils::Instant>| {
-                    let output: Val<bevy::utils::Instant> = <bevy::utils::Instant as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "duration_since",
-                |_self: Ref<bevy::utils::Instant>, earlier: Val<bevy::utils::Instant>| {
-                    let output: Val<bevy::utils::Duration> = bevy::utils::Instant::duration_since(
-                            &_self,
-                            earlier.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "elapsed",
-                |_self: Ref<bevy::utils::Instant>| {
-                    let output: Val<bevy::utils::Duration> = bevy::utils::Instant::elapsed(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::utils::Instant>, other: Ref<bevy::utils::Instant>| {
-                    let output: bool = <bevy::utils::Instant as std::cmp::PartialEq<
-                        bevy::utils::Instant,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "now",
-                || {
-                    let output: Val<bevy::utils::Instant> = bevy::utils::Instant::now()
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_duration_since",
-                |_self: Ref<bevy::utils::Instant>, earlier: Val<bevy::utils::Instant>| {
-                    let output: Val<bevy::utils::Duration> = bevy::utils::Instant::saturating_duration_since(
-                            &_self,
-                            earlier.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::utils::Instant>, other: Val<bevy::utils::Duration>| {
-                    let output: Val<bevy::utils::Instant> = <bevy::utils::Instant as std::ops::Sub<
-                        bevy::utils::Duration,
-                    >>::sub(_self.into_inner(), other.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::utils::Instant>, other: Val<bevy::utils::Instant>| {
-                    let output: Val<bevy::utils::Duration> = <bevy::utils::Instant as std::ops::Sub<
-                        bevy::utils::Instant,
-                    >>::sub(_self.into_inner(), other.into_inner())
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::std::ops::RangeFull>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<std::ops::RangeFull>| {
-                    let output: () = <std::ops::RangeFull as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<std::ops::RangeFull>| {
-                    let output: Val<std::ops::RangeFull> = <std::ops::RangeFull as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<std::ops::RangeFull>, other: Ref<std::ops::RangeFull>| {
-                    let output: bool = <std::ops::RangeFull as std::cmp::PartialEq<
-                        std::ops::RangeFull,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::Quat>::new(world)
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Val<bevy::math::Quat>,
-                    rhs: Val<bevy::math::Quat>,
-                    max_abs_diff: f32|
-                {
-                    let output: bool = bevy::math::Quat::abs_diff_eq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Quat>| {
-                    let output: Val<bevy::math::Quat> = <bevy::math::Quat as std::ops::Add<
-                        bevy::math::Quat,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "angle_between",
-                |_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Quat>| {
-                    let output: f32 = bevy::math::Quat::angle_between(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dquat",
-                |_self: Val<bevy::math::Quat>| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::Quat::as_dquat(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::Quat>| {
-                    let output: Val<bevy::math::Quat> = <bevy::math::Quat as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "conjugate",
-                |_self: Val<bevy::math::Quat>| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::conjugate(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::Quat>, rhs: f32| {
-                    let output: Val<bevy::math::Quat> = <bevy::math::Quat as std::ops::Div<
-                        f32,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Quat>| {
-                    let output: f32 = bevy::math::Quat::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::Quat>, rhs: Ref<bevy::math::Quat>| {
-                    let output: bool = <bevy::math::Quat as std::cmp::PartialEq<
-                        bevy::math::Quat,
-                    >>::eq(&_self, &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_affine3",
-                |a: Ref<bevy::math::Affine3A>| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::from_affine3(
-                            &a,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [f32; 4]| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::from_array(a)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_axis_angle",
-                |axis: Val<bevy::math::Vec3>, angle: f32| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::from_axis_angle(
-                            axis.into_inner(),
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_euler",
-                |euler: Val<bevy::math::EulerRot>, a: f32, b: f32, c: f32| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::from_euler(
-                            euler.into_inner(),
-                            a,
-                            b,
-                            c,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat3",
-                |mat: Ref<bevy::math::Mat3>| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::from_mat3(&mat)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat3a",
-                |mat: Ref<bevy::math::Mat3A>| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::from_mat3a(
-                            &mat,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat4",
-                |mat: Ref<bevy::math::Mat4>| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::from_mat4(&mat)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_arc",
-                |from: Val<bevy::math::Vec3>, to: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::from_rotation_arc(
-                            from.into_inner(),
-                            to.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_arc_2d",
-                |from: Val<bevy::math::Vec2>, to: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::from_rotation_arc_2d(
-                            from.into_inner(),
-                            to.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_arc_colinear",
-                |from: Val<bevy::math::Vec3>, to: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::from_rotation_arc_colinear(
-                            from.into_inner(),
-                            to.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_x",
-                |angle: f32| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::from_rotation_x(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_y",
-                |angle: f32| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::from_rotation_y(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_z",
-                |angle: f32| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::from_rotation_z(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scaled_axis",
-                |v: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::from_scaled_axis(
-                            v.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_vec4",
-                |v: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::from_vec4(
-                            v.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_xyzw",
-                |x: f32, y: f32, z: f32, w: f32| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::from_xyzw(
-                            x,
-                            y,
-                            z,
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse",
-                |_self: Val<bevy::math::Quat>| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::inverse(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Val<bevy::math::Quat>| {
-                    let output: bool = bevy::math::Quat::is_finite(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Val<bevy::math::Quat>| {
-                    let output: bool = bevy::math::Quat::is_nan(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_near_identity",
-                |_self: Val<bevy::math::Quat>| {
-                    let output: bool = bevy::math::Quat::is_near_identity(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_normalized",
-                |_self: Val<bevy::math::Quat>| {
-                    let output: bool = bevy::math::Quat::is_normalized(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length",
-                |_self: Val<bevy::math::Quat>| {
-                    let output: f32 = bevy::math::Quat::length(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_recip",
-                |_self: Val<bevy::math::Quat>| {
-                    let output: f32 = bevy::math::Quat::length_recip(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::Quat>| {
-                    let output: f32 = bevy::math::Quat::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "lerp",
-                |_self: Val<bevy::math::Quat>, end: Val<bevy::math::Quat>, s: f32| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::lerp(
-                            _self.into_inner(),
-                            end.into_inner(),
-                            s,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Quat>| {
-                    let output: Val<bevy::math::Quat> = <bevy::math::Quat as std::ops::Mul<
-                        bevy::math::Quat,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Quat as std::ops::Mul<
-                        bevy::math::Vec3,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Quat as std::ops::Mul<
-                        bevy::math::Vec3A,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Quat>, rhs: f32| {
-                    let output: Val<bevy::math::Quat> = <bevy::math::Quat as std::ops::Mul<
-                        f32,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_quat",
-                |_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Quat>| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::mul_quat(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_vec3",
-                |_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Quat::mul_vec3(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_vec3a",
-                |_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Quat::mul_vec3a(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::Quat>| {
-                    let output: Val<bevy::math::Quat> = <bevy::math::Quat as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize",
-                |_self: Val<bevy::math::Quat>| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::normalize(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotate_towards",
-                |
-                    _self: Ref<bevy::math::Quat>,
-                    rhs: Val<bevy::math::Quat>,
-                    max_angle: f32|
-                {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::rotate_towards(
-                            &_self,
-                            rhs.into_inner(),
-                            max_angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "slerp",
-                |_self: Val<bevy::math::Quat>, end: Val<bevy::math::Quat>, s: f32| {
-                    let output: Val<bevy::math::Quat> = bevy::math::Quat::slerp(
-                            _self.into_inner(),
-                            end.into_inner(),
-                            s,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::Quat>, rhs: Val<bevy::math::Quat>| {
-                    let output: Val<bevy::math::Quat> = <bevy::math::Quat as std::ops::Sub<
-                        bevy::math::Quat,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::Quat>| {
-                    let output: [f32; 4] = bevy::math::Quat::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "to_euler",
-                |_self: Val<bevy::math::Quat>, order: Val<bevy::math::EulerRot>| {
-                    let output: (f32, f32, f32) = bevy::math::Quat::to_euler(
-                            _self.into_inner(),
-                            order.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_scaled_axis",
-                |_self: Val<bevy::math::Quat>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Quat::to_scaled_axis(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "xyz",
-                |_self: Val<bevy::math::Quat>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Quat::xyz(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::Vec3>::new(world)
-            .register(
-                "abs",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::abs(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Val<bevy::math::Vec3>,
-                    rhs: Val<bevy::math::Vec3>,
-                    max_abs_diff: f32|
-                {
-                    let output: bool = bevy::math::Vec3::abs_diff_eq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::Vec3>, rhs: Ref<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Add<
-                        &bevy::math::Vec3,
-                    >>::add(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Add<
-                        bevy::math::Vec3,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::Vec3>, rhs: f32| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Add<
-                        f32,
-                    >>::add(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "angle_between",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: f32 = bevy::math::Vec3::angle_between(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "any_orthogonal_vector",
-                |_self: Ref<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::any_orthogonal_vector(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "any_orthonormal_vector",
-                |_self: Ref<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::any_orthonormal_vector(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dvec3",
-                |_self: Ref<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::Vec3::as_dvec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_i64vec3",
-                |_self: Ref<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::Vec3::as_i64vec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_ivec3",
-                |_self: Ref<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::Vec3::as_ivec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_u64vec3",
-                |_self: Ref<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::Vec3::as_u64vec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_uvec3",
-                |_self: Ref<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::Vec3::as_uvec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "ceil",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::ceil(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp",
-                |
-                    _self: Val<bevy::math::Vec3>,
-                    min: Val<bevy::math::Vec3>,
-                    max: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::clamp(
-                            _self.into_inner(),
-                            min.into_inner(),
-                            max.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length",
-                |_self: Val<bevy::math::Vec3>, min: f32, max: f32| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::clamp_length(
-                            _self.into_inner(),
-                            min,
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length_max",
-                |_self: Val<bevy::math::Vec3>, max: f32| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::clamp_length_max(
-                            _self.into_inner(),
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length_min",
-                |_self: Val<bevy::math::Vec3>, min: f32| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::clamp_length_min(
-                            _self.into_inner(),
-                            min,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpeq",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::Vec3::cmpeq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpge",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::Vec3::cmpge(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpgt",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::Vec3::cmpgt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmple",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::Vec3::cmple(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmplt",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::Vec3::cmplt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpne",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::Vec3::cmpne(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "copysign",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::copysign(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cross",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::cross(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: f32 = bevy::math::Vec3::distance(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance_squared",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: f32 = bevy::math::Vec3::distance_squared(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::Vec3>, rhs: Ref<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Div<
-                        &bevy::math::Vec3,
-                    >>::div(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Div<
-                        bevy::math::Vec3,
-                    >>::div(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::Vec3>, rhs: f32| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Div<
-                        f32,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_euclid",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::div_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: f32 = bevy::math::Vec3::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot_into_vec",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::dot_into_vec(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_product",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: f32 = bevy::math::Vec3::element_product(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_sum",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: f32 = bevy::math::Vec3::element_sum(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::Vec3>, other: Ref<bevy::math::Vec3>| {
-                    let output: bool = <bevy::math::Vec3 as std::cmp::PartialEq<
-                        bevy::math::Vec3,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "exp",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::exp(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "extend",
-                |_self: Val<bevy::math::Vec3>, w: f32| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec3::extend(
-                            _self.into_inner(),
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "floor",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::floor(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fract",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::fract(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fract_gl",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::fract_gl(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [f32; 3]| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::from_array(a)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: bool = bevy::math::Vec3::is_finite(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite_mask",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::Vec3::is_finite_mask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: bool = bevy::math::Vec3::is_nan(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_nan_mask",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::Vec3::is_nan_mask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_negative_bitmask",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: u32 = bevy::math::Vec3::is_negative_bitmask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_normalized",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: bool = bevy::math::Vec3::is_normalized(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: f32 = bevy::math::Vec3::length(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_recip",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: f32 = bevy::math::Vec3::length_recip(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: f32 = bevy::math::Vec3::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "lerp",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>, s: f32| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::lerp(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                            s,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::max(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max_element",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: f32 = bevy::math::Vec3::max_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "midpoint",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::midpoint(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::min(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min_element",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: f32 = bevy::math::Vec3::min_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "move_towards",
-                |_self: Ref<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>, d: f32| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::move_towards(
-                            &_self,
-                            rhs.into_inner(),
-                            d,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Vec3>, rhs: Ref<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Mul<
-                        &bevy::math::Vec3,
-                    >>::mul(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Mul<
-                        bevy::math::Vec3,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Vec3>, rhs: f32| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Mul<
-                        f32,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_add",
-                |
-                    _self: Val<bevy::math::Vec3>,
-                    a: Val<bevy::math::Vec3>,
-                    b: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::mul_add(
-                            _self.into_inner(),
-                            a.into_inner(),
-                            b.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: f32, y: f32, z: f32| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::new(x, y, z)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::normalize(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize_or",
-                |_self: Val<bevy::math::Vec3>, fallback: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::normalize_or(
-                            _self.into_inner(),
-                            fallback.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize_or_zero",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::normalize_or_zero(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "powf",
-                |_self: Val<bevy::math::Vec3>, n: f32| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::powf(
-                            _self.into_inner(),
-                            n,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "project_onto",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::project_onto(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "project_onto_normalized",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::project_onto_normalized(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "recip",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::recip(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reflect",
-                |_self: Val<bevy::math::Vec3>, normal: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::reflect(
-                            _self.into_inner(),
-                            normal.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "refract",
-                |_self: Val<bevy::math::Vec3>, normal: Val<bevy::math::Vec3>, eta: f32| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::refract(
-                            _self.into_inner(),
-                            normal.into_inner(),
-                            eta,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reject_from",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::reject_from(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reject_from_normalized",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::reject_from_normalized(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::Vec3>, rhs: Ref<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Rem<
-                        &bevy::math::Vec3,
-                    >>::rem(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Rem<
-                        bevy::math::Vec3,
-                    >>::rem(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::Vec3>, rhs: f32| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Rem<
-                        f32,
-                    >>::rem(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem_euclid",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::rem_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "round",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::round(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "select",
-                |
-                    mask: Val<bevy::math::BVec3>,
-                    if_true: Val<bevy::math::Vec3>,
-                    if_false: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::select(
-                            mask.into_inner(),
-                            if_true.into_inner(),
-                            if_false.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "signum",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::signum(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: f32| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::Vec3>, rhs: Ref<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Sub<
-                        &bevy::math::Vec3,
-                    >>::sub(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::Vec3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Sub<
-                        bevy::math::Vec3,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::Vec3>, rhs: f32| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Vec3 as std::ops::Sub<
-                        f32,
-                    >>::sub(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::Vec3>| {
-                    let output: [f32; 3] = bevy::math::Vec3::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "trunc",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::trunc(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "truncate",
-                |_self: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec3::truncate(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_x",
-                |_self: Val<bevy::math::Vec3>, x: f32| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::with_x(
-                            _self.into_inner(),
-                            x,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_y",
-                |_self: Val<bevy::math::Vec3>, y: f32| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::with_y(
-                            _self.into_inner(),
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_z",
-                |_self: Val<bevy::math::Vec3>, z: f32| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec3::with_z(
-                            _self.into_inner(),
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::IVec2>::new(world)
-            .register(
-                "abs",
-                |_self: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::abs(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::IVec2>, rhs: Ref<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Add<
-                        &bevy::math::IVec2,
-                    >>::add(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Add<
-                        bevy::math::IVec2,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::IVec2>, rhs: i32| {
-                    let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Add<
-                        i32,
-                    >>::add(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dvec2",
-                |_self: Ref<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::IVec2::as_dvec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_i64vec2",
-                |_self: Ref<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::IVec2::as_i64vec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_u64vec2",
-                |_self: Ref<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::IVec2::as_u64vec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_uvec2",
-                |_self: Ref<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::IVec2::as_uvec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec2",
-                |_self: Ref<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::IVec2::as_vec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::IVec2>| {
-                    let output: () = <bevy::math::IVec2 as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp",
-                |
-                    _self: Val<bevy::math::IVec2>,
-                    min: Val<bevy::math::IVec2>,
-                    max: Val<bevy::math::IVec2>|
-                {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::clamp(
-                            _self.into_inner(),
-                            min.into_inner(),
-                            max.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpeq",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::IVec2::cmpeq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpge",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::IVec2::cmpge(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpgt",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::IVec2::cmpgt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmple",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::IVec2::cmple(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmplt",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::IVec2::cmplt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpne",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::IVec2::cmpne(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance_squared",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: i32 = bevy::math::IVec2::distance_squared(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::IVec2>, rhs: Ref<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Div<
-                        &bevy::math::IVec2,
-                    >>::div(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Div<
-                        bevy::math::IVec2,
-                    >>::div(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::IVec2>, rhs: i32| {
-                    let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Div<
-                        i32,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_euclid",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::div_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: i32 = bevy::math::IVec2::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot_into_vec",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::dot_into_vec(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_product",
-                |_self: Val<bevy::math::IVec2>| {
-                    let output: i32 = bevy::math::IVec2::element_product(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_sum",
-                |_self: Val<bevy::math::IVec2>| {
-                    let output: i32 = bevy::math::IVec2::element_sum(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::IVec2>, other: Ref<bevy::math::IVec2>| {
-                    let output: bool = <bevy::math::IVec2 as std::cmp::PartialEq<
-                        bevy::math::IVec2,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "extend",
-                |_self: Val<bevy::math::IVec2>, z: i32| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec2::extend(
-                            _self.into_inner(),
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [i32; 2]| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::from_array(a)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_negative_bitmask",
-                |_self: Val<bevy::math::IVec2>| {
-                    let output: u32 = bevy::math::IVec2::is_negative_bitmask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::IVec2>| {
-                    let output: i32 = bevy::math::IVec2::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::max(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max_element",
-                |_self: Val<bevy::math::IVec2>| {
-                    let output: i32 = bevy::math::IVec2::max_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::min(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min_element",
-                |_self: Val<bevy::math::IVec2>| {
-                    let output: i32 = bevy::math::IVec2::min_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::IVec2>, rhs: Ref<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Mul<
-                        &bevy::math::IVec2,
-                    >>::mul(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Mul<
-                        bevy::math::IVec2,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::IVec2>, rhs: i32| {
-                    let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Mul<
-                        i32,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: i32, y: i32| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::new(x, y)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perp",
-                |_self: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::perp(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perp_dot",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: i32 = bevy::math::IVec2::perp_dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::IVec2>, rhs: Ref<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Rem<
-                        &bevy::math::IVec2,
-                    >>::rem(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Rem<
-                        bevy::math::IVec2,
-                    >>::rem(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::IVec2>, rhs: i32| {
-                    let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Rem<
-                        i32,
-                    >>::rem(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem_euclid",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::rem_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotate",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::rotate(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::saturating_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add_unsigned",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::saturating_add_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_div",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::saturating_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_mul",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::saturating_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_sub",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::saturating_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_sub_unsigned",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::saturating_sub_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "select",
-                |
-                    mask: Val<bevy::math::BVec2>,
-                    if_true: Val<bevy::math::IVec2>,
-                    if_false: Val<bevy::math::IVec2>|
-                {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::select(
-                            mask.into_inner(),
-                            if_true.into_inner(),
-                            if_false.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "signum",
-                |_self: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::signum(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: i32| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::IVec2>, rhs: Ref<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Sub<
-                        &bevy::math::IVec2,
-                    >>::sub(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Sub<
-                        bevy::math::IVec2,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::IVec2>, rhs: i32| {
-                    let output: Val<bevy::math::IVec2> = <bevy::math::IVec2 as std::ops::Sub<
-                        i32,
-                    >>::sub(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::IVec2>| {
-                    let output: [i32; 2] = bevy::math::IVec2::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "with_x",
-                |_self: Val<bevy::math::IVec2>, x: i32| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::with_x(
-                            _self.into_inner(),
-                            x,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_y",
-                |_self: Val<bevy::math::IVec2>, y: i32| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::with_y(
-                            _self.into_inner(),
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::wrapping_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add_unsigned",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::wrapping_add_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_div",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::wrapping_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_mul",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::wrapping_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_sub",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::wrapping_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_sub_unsigned",
-                |_self: Val<bevy::math::IVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec2::wrapping_sub_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::IVec3>::new(world)
-            .register(
-                "abs",
-                |_self: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::abs(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::IVec3>, rhs: Ref<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Add<
-                        &bevy::math::IVec3,
-                    >>::add(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Add<
-                        bevy::math::IVec3,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::IVec3>, rhs: i32| {
-                    let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Add<
-                        i32,
-                    >>::add(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dvec3",
-                |_self: Ref<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::IVec3::as_dvec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_i64vec3",
-                |_self: Ref<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::IVec3::as_i64vec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_u64vec3",
-                |_self: Ref<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::IVec3::as_u64vec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_uvec3",
-                |_self: Ref<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::IVec3::as_uvec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec3",
-                |_self: Ref<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::IVec3::as_vec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec3a",
-                |_self: Ref<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::IVec3::as_vec3a(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::IVec3>| {
-                    let output: () = <bevy::math::IVec3 as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp",
-                |
-                    _self: Val<bevy::math::IVec3>,
-                    min: Val<bevy::math::IVec3>,
-                    max: Val<bevy::math::IVec3>|
-                {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::clamp(
-                            _self.into_inner(),
-                            min.into_inner(),
-                            max.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpeq",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::IVec3::cmpeq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpge",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::IVec3::cmpge(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpgt",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::IVec3::cmpgt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmple",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::IVec3::cmple(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmplt",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::IVec3::cmplt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpne",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::IVec3::cmpne(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cross",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::cross(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance_squared",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: i32 = bevy::math::IVec3::distance_squared(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::IVec3>, rhs: Ref<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Div<
-                        &bevy::math::IVec3,
-                    >>::div(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Div<
-                        bevy::math::IVec3,
-                    >>::div(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::IVec3>, rhs: i32| {
-                    let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Div<
-                        i32,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_euclid",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::div_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: i32 = bevy::math::IVec3::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot_into_vec",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::dot_into_vec(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_product",
-                |_self: Val<bevy::math::IVec3>| {
-                    let output: i32 = bevy::math::IVec3::element_product(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_sum",
-                |_self: Val<bevy::math::IVec3>| {
-                    let output: i32 = bevy::math::IVec3::element_sum(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::IVec3>, other: Ref<bevy::math::IVec3>| {
-                    let output: bool = <bevy::math::IVec3 as std::cmp::PartialEq<
-                        bevy::math::IVec3,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "extend",
-                |_self: Val<bevy::math::IVec3>, w: i32| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec3::extend(
-                            _self.into_inner(),
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [i32; 3]| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::from_array(a)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_negative_bitmask",
-                |_self: Val<bevy::math::IVec3>| {
-                    let output: u32 = bevy::math::IVec3::is_negative_bitmask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::IVec3>| {
-                    let output: i32 = bevy::math::IVec3::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::max(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max_element",
-                |_self: Val<bevy::math::IVec3>| {
-                    let output: i32 = bevy::math::IVec3::max_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::min(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min_element",
-                |_self: Val<bevy::math::IVec3>| {
-                    let output: i32 = bevy::math::IVec3::min_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::IVec3>, rhs: Ref<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Mul<
-                        &bevy::math::IVec3,
-                    >>::mul(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Mul<
-                        bevy::math::IVec3,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::IVec3>, rhs: i32| {
-                    let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Mul<
-                        i32,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: i32, y: i32, z: i32| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::new(x, y, z)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::IVec3>, rhs: Ref<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Rem<
-                        &bevy::math::IVec3,
-                    >>::rem(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Rem<
-                        bevy::math::IVec3,
-                    >>::rem(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::IVec3>, rhs: i32| {
-                    let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Rem<
-                        i32,
-                    >>::rem(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem_euclid",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::rem_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::saturating_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add_unsigned",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::saturating_add_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_div",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::saturating_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_mul",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::saturating_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_sub",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::saturating_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_sub_unsigned",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::saturating_sub_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "select",
-                |
-                    mask: Val<bevy::math::BVec3>,
-                    if_true: Val<bevy::math::IVec3>,
-                    if_false: Val<bevy::math::IVec3>|
-                {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::select(
-                            mask.into_inner(),
-                            if_true.into_inner(),
-                            if_false.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "signum",
-                |_self: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::signum(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: i32| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::IVec3>, rhs: Ref<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Sub<
-                        &bevy::math::IVec3,
-                    >>::sub(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Sub<
-                        bevy::math::IVec3,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::IVec3>, rhs: i32| {
-                    let output: Val<bevy::math::IVec3> = <bevy::math::IVec3 as std::ops::Sub<
-                        i32,
-                    >>::sub(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::IVec3>| {
-                    let output: [i32; 3] = bevy::math::IVec3::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "truncate",
-                |_self: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::IVec3::truncate(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_x",
-                |_self: Val<bevy::math::IVec3>, x: i32| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::with_x(
-                            _self.into_inner(),
-                            x,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_y",
-                |_self: Val<bevy::math::IVec3>, y: i32| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::with_y(
-                            _self.into_inner(),
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_z",
-                |_self: Val<bevy::math::IVec3>, z: i32| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::with_z(
-                            _self.into_inner(),
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::wrapping_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add_unsigned",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::wrapping_add_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_div",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::wrapping_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_mul",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::wrapping_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_sub",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::wrapping_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_sub_unsigned",
-                |_self: Val<bevy::math::IVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec3::wrapping_sub_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::IVec4>::new(world)
-            .register(
-                "abs",
-                |_self: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::abs(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::IVec4>, rhs: Ref<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Add<
-                        &bevy::math::IVec4,
-                    >>::add(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Add<
-                        bevy::math::IVec4,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::IVec4>, rhs: i32| {
-                    let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Add<
-                        i32,
-                    >>::add(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dvec4",
-                |_self: Ref<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::IVec4::as_dvec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_i64vec4",
-                |_self: Ref<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::IVec4::as_i64vec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_u64vec4",
-                |_self: Ref<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::IVec4::as_u64vec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_uvec4",
-                |_self: Ref<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::IVec4::as_uvec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec4",
-                |_self: Ref<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::IVec4::as_vec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::IVec4>| {
-                    let output: () = <bevy::math::IVec4 as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp",
-                |
-                    _self: Val<bevy::math::IVec4>,
-                    min: Val<bevy::math::IVec4>,
-                    max: Val<bevy::math::IVec4>|
-                {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::clamp(
-                            _self.into_inner(),
-                            min.into_inner(),
-                            max.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpeq",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::IVec4::cmpeq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpge",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::IVec4::cmpge(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpgt",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::IVec4::cmpgt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmple",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::IVec4::cmple(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmplt",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::IVec4::cmplt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpne",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::IVec4::cmpne(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance_squared",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: i32 = bevy::math::IVec4::distance_squared(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::IVec4>, rhs: Ref<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Div<
-                        &bevy::math::IVec4,
-                    >>::div(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Div<
-                        bevy::math::IVec4,
-                    >>::div(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::IVec4>, rhs: i32| {
-                    let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Div<
-                        i32,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_euclid",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::div_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: i32 = bevy::math::IVec4::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot_into_vec",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::dot_into_vec(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_product",
-                |_self: Val<bevy::math::IVec4>| {
-                    let output: i32 = bevy::math::IVec4::element_product(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_sum",
-                |_self: Val<bevy::math::IVec4>| {
-                    let output: i32 = bevy::math::IVec4::element_sum(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::IVec4>, other: Ref<bevy::math::IVec4>| {
-                    let output: bool = <bevy::math::IVec4 as std::cmp::PartialEq<
-                        bevy::math::IVec4,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [i32; 4]| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::from_array(a)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_negative_bitmask",
-                |_self: Val<bevy::math::IVec4>| {
-                    let output: u32 = bevy::math::IVec4::is_negative_bitmask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::IVec4>| {
-                    let output: i32 = bevy::math::IVec4::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::max(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max_element",
-                |_self: Val<bevy::math::IVec4>| {
-                    let output: i32 = bevy::math::IVec4::max_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::min(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min_element",
-                |_self: Val<bevy::math::IVec4>| {
-                    let output: i32 = bevy::math::IVec4::min_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::IVec4>, rhs: Ref<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Mul<
-                        &bevy::math::IVec4,
-                    >>::mul(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Mul<
-                        bevy::math::IVec4,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::IVec4>, rhs: i32| {
-                    let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Mul<
-                        i32,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: i32, y: i32, z: i32, w: i32| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::new(
-                            x,
-                            y,
-                            z,
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::IVec4>, rhs: Ref<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Rem<
-                        &bevy::math::IVec4,
-                    >>::rem(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Rem<
-                        bevy::math::IVec4,
-                    >>::rem(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::IVec4>, rhs: i32| {
-                    let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Rem<
-                        i32,
-                    >>::rem(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem_euclid",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::rem_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::saturating_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add_unsigned",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::saturating_add_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_div",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::saturating_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_mul",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::saturating_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_sub",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::saturating_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_sub_unsigned",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::saturating_sub_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "select",
-                |
-                    mask: Val<bevy::math::BVec4>,
-                    if_true: Val<bevy::math::IVec4>,
-                    if_false: Val<bevy::math::IVec4>|
-                {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::select(
-                            mask.into_inner(),
-                            if_true.into_inner(),
-                            if_false.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "signum",
-                |_self: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::signum(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: i32| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::IVec4>, rhs: Ref<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Sub<
-                        &bevy::math::IVec4,
-                    >>::sub(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Sub<
-                        bevy::math::IVec4,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::IVec4>, rhs: i32| {
-                    let output: Val<bevy::math::IVec4> = <bevy::math::IVec4 as std::ops::Sub<
-                        i32,
-                    >>::sub(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::IVec4>| {
-                    let output: [i32; 4] = bevy::math::IVec4::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "truncate",
-                |_self: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::IVec4::truncate(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_w",
-                |_self: Val<bevy::math::IVec4>, w: i32| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::with_w(
-                            _self.into_inner(),
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_x",
-                |_self: Val<bevy::math::IVec4>, x: i32| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::with_x(
-                            _self.into_inner(),
-                            x,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_y",
-                |_self: Val<bevy::math::IVec4>, y: i32| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::with_y(
-                            _self.into_inner(),
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_z",
-                |_self: Val<bevy::math::IVec4>, z: i32| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::with_z(
-                            _self.into_inner(),
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::wrapping_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add_unsigned",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::wrapping_add_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_div",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::wrapping_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_mul",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::wrapping_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_sub",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::wrapping_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_sub_unsigned",
-                |_self: Val<bevy::math::IVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::IVec4::wrapping_sub_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::I64Vec2>::new(world)
-            .register(
-                "abs",
-                |_self: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::abs(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Ref<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Add<
-                        &bevy::math::I64Vec2,
-                    >>::add(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Add<
-                        bevy::math::I64Vec2,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::I64Vec2>, rhs: i64| {
-                    let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Add<
-                        i64,
-                    >>::add(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dvec2",
-                |_self: Ref<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::I64Vec2::as_dvec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_ivec2",
-                |_self: Ref<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::I64Vec2::as_ivec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_u64vec2",
-                |_self: Ref<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::I64Vec2::as_u64vec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_uvec2",
-                |_self: Ref<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::I64Vec2::as_uvec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec2",
-                |_self: Ref<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::I64Vec2::as_vec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::I64Vec2>| {
-                    let output: () = <bevy::math::I64Vec2 as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp",
-                |
-                    _self: Val<bevy::math::I64Vec2>,
-                    min: Val<bevy::math::I64Vec2>,
-                    max: Val<bevy::math::I64Vec2>|
-                {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::clamp(
-                            _self.into_inner(),
-                            min.into_inner(),
-                            max.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpeq",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::I64Vec2::cmpeq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpge",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::I64Vec2::cmpge(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpgt",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::I64Vec2::cmpgt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmple",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::I64Vec2::cmple(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmplt",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::I64Vec2::cmplt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpne",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::I64Vec2::cmpne(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance_squared",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: i64 = bevy::math::I64Vec2::distance_squared(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Ref<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Div<
-                        &bevy::math::I64Vec2,
-                    >>::div(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Div<
-                        bevy::math::I64Vec2,
-                    >>::div(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::I64Vec2>, rhs: i64| {
-                    let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Div<
-                        i64,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_euclid",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::div_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: i64 = bevy::math::I64Vec2::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot_into_vec",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::dot_into_vec(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_product",
-                |_self: Val<bevy::math::I64Vec2>| {
-                    let output: i64 = bevy::math::I64Vec2::element_product(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_sum",
-                |_self: Val<bevy::math::I64Vec2>| {
-                    let output: i64 = bevy::math::I64Vec2::element_sum(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::I64Vec2>, other: Ref<bevy::math::I64Vec2>| {
-                    let output: bool = <bevy::math::I64Vec2 as std::cmp::PartialEq<
-                        bevy::math::I64Vec2,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "extend",
-                |_self: Val<bevy::math::I64Vec2>, z: i64| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec2::extend(
-                            _self.into_inner(),
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [i64; 2]| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::from_array(
-                            a,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_negative_bitmask",
-                |_self: Val<bevy::math::I64Vec2>| {
-                    let output: u32 = bevy::math::I64Vec2::is_negative_bitmask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::I64Vec2>| {
-                    let output: i64 = bevy::math::I64Vec2::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::max(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max_element",
-                |_self: Val<bevy::math::I64Vec2>| {
-                    let output: i64 = bevy::math::I64Vec2::max_element(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::min(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min_element",
-                |_self: Val<bevy::math::I64Vec2>| {
-                    let output: i64 = bevy::math::I64Vec2::min_element(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Ref<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Mul<
-                        &bevy::math::I64Vec2,
-                    >>::mul(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Mul<
-                        bevy::math::I64Vec2,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::I64Vec2>, rhs: i64| {
-                    let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Mul<
-                        i64,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: i64, y: i64| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::new(x, y)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perp",
-                |_self: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::perp(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perp_dot",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: i64 = bevy::math::I64Vec2::perp_dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Ref<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Rem<
-                        &bevy::math::I64Vec2,
-                    >>::rem(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Rem<
-                        bevy::math::I64Vec2,
-                    >>::rem(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::I64Vec2>, rhs: i64| {
-                    let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Rem<
-                        i64,
-                    >>::rem(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem_euclid",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::rem_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotate",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::rotate(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::saturating_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add_unsigned",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::saturating_add_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_div",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::saturating_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_mul",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::saturating_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_sub",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::saturating_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_sub_unsigned",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::saturating_sub_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "select",
-                |
-                    mask: Val<bevy::math::BVec2>,
-                    if_true: Val<bevy::math::I64Vec2>,
-                    if_false: Val<bevy::math::I64Vec2>|
-                {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::select(
-                            mask.into_inner(),
-                            if_true.into_inner(),
-                            if_false.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "signum",
-                |_self: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::signum(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: i64| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Ref<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Sub<
-                        &bevy::math::I64Vec2,
-                    >>::sub(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Sub<
-                        bevy::math::I64Vec2,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::I64Vec2>, rhs: i64| {
-                    let output: Val<bevy::math::I64Vec2> = <bevy::math::I64Vec2 as std::ops::Sub<
-                        i64,
-                    >>::sub(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::I64Vec2>| {
-                    let output: [i64; 2] = bevy::math::I64Vec2::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "with_x",
-                |_self: Val<bevy::math::I64Vec2>, x: i64| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::with_x(
-                            _self.into_inner(),
-                            x,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_y",
-                |_self: Val<bevy::math::I64Vec2>, y: i64| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::with_y(
-                            _self.into_inner(),
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::wrapping_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add_unsigned",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::wrapping_add_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_div",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::wrapping_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_mul",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::wrapping_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_sub",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::wrapping_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_sub_unsigned",
-                |_self: Val<bevy::math::I64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec2::wrapping_sub_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::I64Vec3>::new(world)
-            .register(
-                "abs",
-                |_self: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::abs(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Ref<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Add<
-                        &bevy::math::I64Vec3,
-                    >>::add(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Add<
-                        bevy::math::I64Vec3,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::I64Vec3>, rhs: i64| {
-                    let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Add<
-                        i64,
-                    >>::add(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dvec3",
-                |_self: Ref<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::I64Vec3::as_dvec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_ivec3",
-                |_self: Ref<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::I64Vec3::as_ivec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_u64vec3",
-                |_self: Ref<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::I64Vec3::as_u64vec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_uvec3",
-                |_self: Ref<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::I64Vec3::as_uvec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec3",
-                |_self: Ref<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::I64Vec3::as_vec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec3a",
-                |_self: Ref<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::I64Vec3::as_vec3a(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::I64Vec3>| {
-                    let output: () = <bevy::math::I64Vec3 as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp",
-                |
-                    _self: Val<bevy::math::I64Vec3>,
-                    min: Val<bevy::math::I64Vec3>,
-                    max: Val<bevy::math::I64Vec3>|
-                {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::clamp(
-                            _self.into_inner(),
-                            min.into_inner(),
-                            max.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpeq",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::I64Vec3::cmpeq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpge",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::I64Vec3::cmpge(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpgt",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::I64Vec3::cmpgt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmple",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::I64Vec3::cmple(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmplt",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::I64Vec3::cmplt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpne",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::I64Vec3::cmpne(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cross",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::cross(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance_squared",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: i64 = bevy::math::I64Vec3::distance_squared(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Ref<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Div<
-                        &bevy::math::I64Vec3,
-                    >>::div(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Div<
-                        bevy::math::I64Vec3,
-                    >>::div(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::I64Vec3>, rhs: i64| {
-                    let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Div<
-                        i64,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_euclid",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::div_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: i64 = bevy::math::I64Vec3::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot_into_vec",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::dot_into_vec(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_product",
-                |_self: Val<bevy::math::I64Vec3>| {
-                    let output: i64 = bevy::math::I64Vec3::element_product(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_sum",
-                |_self: Val<bevy::math::I64Vec3>| {
-                    let output: i64 = bevy::math::I64Vec3::element_sum(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::I64Vec3>, other: Ref<bevy::math::I64Vec3>| {
-                    let output: bool = <bevy::math::I64Vec3 as std::cmp::PartialEq<
-                        bevy::math::I64Vec3,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "extend",
-                |_self: Val<bevy::math::I64Vec3>, w: i64| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec3::extend(
-                            _self.into_inner(),
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [i64; 3]| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::from_array(
-                            a,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_negative_bitmask",
-                |_self: Val<bevy::math::I64Vec3>| {
-                    let output: u32 = bevy::math::I64Vec3::is_negative_bitmask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::I64Vec3>| {
-                    let output: i64 = bevy::math::I64Vec3::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::max(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max_element",
-                |_self: Val<bevy::math::I64Vec3>| {
-                    let output: i64 = bevy::math::I64Vec3::max_element(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::min(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min_element",
-                |_self: Val<bevy::math::I64Vec3>| {
-                    let output: i64 = bevy::math::I64Vec3::min_element(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Ref<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Mul<
-                        &bevy::math::I64Vec3,
-                    >>::mul(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Mul<
-                        bevy::math::I64Vec3,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::I64Vec3>, rhs: i64| {
-                    let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Mul<
-                        i64,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: i64, y: i64, z: i64| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::new(
-                            x,
-                            y,
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Ref<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Rem<
-                        &bevy::math::I64Vec3,
-                    >>::rem(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Rem<
-                        bevy::math::I64Vec3,
-                    >>::rem(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::I64Vec3>, rhs: i64| {
-                    let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Rem<
-                        i64,
-                    >>::rem(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem_euclid",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::rem_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::saturating_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add_unsigned",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::saturating_add_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_div",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::saturating_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_mul",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::saturating_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_sub",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::saturating_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_sub_unsigned",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::saturating_sub_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "select",
-                |
-                    mask: Val<bevy::math::BVec3>,
-                    if_true: Val<bevy::math::I64Vec3>,
-                    if_false: Val<bevy::math::I64Vec3>|
-                {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::select(
-                            mask.into_inner(),
-                            if_true.into_inner(),
-                            if_false.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "signum",
-                |_self: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::signum(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: i64| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Ref<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Sub<
-                        &bevy::math::I64Vec3,
-                    >>::sub(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Sub<
-                        bevy::math::I64Vec3,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::I64Vec3>, rhs: i64| {
-                    let output: Val<bevy::math::I64Vec3> = <bevy::math::I64Vec3 as std::ops::Sub<
-                        i64,
-                    >>::sub(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::I64Vec3>| {
-                    let output: [i64; 3] = bevy::math::I64Vec3::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "truncate",
-                |_self: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::I64Vec3::truncate(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_x",
-                |_self: Val<bevy::math::I64Vec3>, x: i64| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::with_x(
-                            _self.into_inner(),
-                            x,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_y",
-                |_self: Val<bevy::math::I64Vec3>, y: i64| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::with_y(
-                            _self.into_inner(),
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_z",
-                |_self: Val<bevy::math::I64Vec3>, z: i64| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::with_z(
-                            _self.into_inner(),
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::wrapping_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add_unsigned",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::wrapping_add_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_div",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::wrapping_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_mul",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::wrapping_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_sub",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::wrapping_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_sub_unsigned",
-                |_self: Val<bevy::math::I64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec3::wrapping_sub_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::I64Vec4>::new(world)
-            .register(
-                "abs",
-                |_self: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::abs(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Ref<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Add<
-                        &bevy::math::I64Vec4,
-                    >>::add(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Add<
-                        bevy::math::I64Vec4,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::I64Vec4>, rhs: i64| {
-                    let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Add<
-                        i64,
-                    >>::add(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dvec4",
-                |_self: Ref<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::I64Vec4::as_dvec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_ivec4",
-                |_self: Ref<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::I64Vec4::as_ivec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_u64vec4",
-                |_self: Ref<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::I64Vec4::as_u64vec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_uvec4",
-                |_self: Ref<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::I64Vec4::as_uvec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec4",
-                |_self: Ref<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::I64Vec4::as_vec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::I64Vec4>| {
-                    let output: () = <bevy::math::I64Vec4 as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp",
-                |
-                    _self: Val<bevy::math::I64Vec4>,
-                    min: Val<bevy::math::I64Vec4>,
-                    max: Val<bevy::math::I64Vec4>|
-                {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::clamp(
-                            _self.into_inner(),
-                            min.into_inner(),
-                            max.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpeq",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::I64Vec4::cmpeq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpge",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::I64Vec4::cmpge(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpgt",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::I64Vec4::cmpgt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmple",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::I64Vec4::cmple(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmplt",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::I64Vec4::cmplt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpne",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::I64Vec4::cmpne(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance_squared",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: i64 = bevy::math::I64Vec4::distance_squared(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Ref<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Div<
-                        &bevy::math::I64Vec4,
-                    >>::div(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Div<
-                        bevy::math::I64Vec4,
-                    >>::div(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::I64Vec4>, rhs: i64| {
-                    let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Div<
-                        i64,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_euclid",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::div_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: i64 = bevy::math::I64Vec4::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot_into_vec",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::dot_into_vec(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_product",
-                |_self: Val<bevy::math::I64Vec4>| {
-                    let output: i64 = bevy::math::I64Vec4::element_product(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_sum",
-                |_self: Val<bevy::math::I64Vec4>| {
-                    let output: i64 = bevy::math::I64Vec4::element_sum(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::I64Vec4>, other: Ref<bevy::math::I64Vec4>| {
-                    let output: bool = <bevy::math::I64Vec4 as std::cmp::PartialEq<
-                        bevy::math::I64Vec4,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [i64; 4]| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::from_array(
-                            a,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_negative_bitmask",
-                |_self: Val<bevy::math::I64Vec4>| {
-                    let output: u32 = bevy::math::I64Vec4::is_negative_bitmask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::I64Vec4>| {
-                    let output: i64 = bevy::math::I64Vec4::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::max(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max_element",
-                |_self: Val<bevy::math::I64Vec4>| {
-                    let output: i64 = bevy::math::I64Vec4::max_element(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::min(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min_element",
-                |_self: Val<bevy::math::I64Vec4>| {
-                    let output: i64 = bevy::math::I64Vec4::min_element(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Ref<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Mul<
-                        &bevy::math::I64Vec4,
-                    >>::mul(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Mul<
-                        bevy::math::I64Vec4,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::I64Vec4>, rhs: i64| {
-                    let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Mul<
-                        i64,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: i64, y: i64, z: i64, w: i64| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::new(
-                            x,
-                            y,
-                            z,
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Ref<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Rem<
-                        &bevy::math::I64Vec4,
-                    >>::rem(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Rem<
-                        bevy::math::I64Vec4,
-                    >>::rem(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::I64Vec4>, rhs: i64| {
-                    let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Rem<
-                        i64,
-                    >>::rem(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem_euclid",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::rem_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::saturating_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add_unsigned",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::saturating_add_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_div",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::saturating_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_mul",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::saturating_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_sub",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::saturating_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_sub_unsigned",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::saturating_sub_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "select",
-                |
-                    mask: Val<bevy::math::BVec4>,
-                    if_true: Val<bevy::math::I64Vec4>,
-                    if_false: Val<bevy::math::I64Vec4>|
-                {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::select(
-                            mask.into_inner(),
-                            if_true.into_inner(),
-                            if_false.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "signum",
-                |_self: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::signum(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: i64| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Ref<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Sub<
-                        &bevy::math::I64Vec4,
-                    >>::sub(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Sub<
-                        bevy::math::I64Vec4,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::I64Vec4>, rhs: i64| {
-                    let output: Val<bevy::math::I64Vec4> = <bevy::math::I64Vec4 as std::ops::Sub<
-                        i64,
-                    >>::sub(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::I64Vec4>| {
-                    let output: [i64; 4] = bevy::math::I64Vec4::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "truncate",
-                |_self: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::I64Vec4::truncate(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_w",
-                |_self: Val<bevy::math::I64Vec4>, w: i64| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::with_w(
-                            _self.into_inner(),
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_x",
-                |_self: Val<bevy::math::I64Vec4>, x: i64| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::with_x(
-                            _self.into_inner(),
-                            x,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_y",
-                |_self: Val<bevy::math::I64Vec4>, y: i64| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::with_y(
-                            _self.into_inner(),
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_z",
-                |_self: Val<bevy::math::I64Vec4>, z: i64| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::with_z(
-                            _self.into_inner(),
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::wrapping_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add_unsigned",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::wrapping_add_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_div",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::wrapping_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_mul",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::wrapping_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_sub",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::wrapping_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_sub_unsigned",
-                |_self: Val<bevy::math::I64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::I64Vec4::wrapping_sub_unsigned(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::UVec2>::new(world)
-            .register(
-                "add",
-                |_self: Val<bevy::math::UVec2>, rhs: Ref<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Add<
-                        &bevy::math::UVec2,
-                    >>::add(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Add<
-                        bevy::math::UVec2,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::UVec2>, rhs: u32| {
-                    let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Add<
-                        u32,
-                    >>::add(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dvec2",
-                |_self: Ref<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::UVec2::as_dvec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_i64vec2",
-                |_self: Ref<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::UVec2::as_i64vec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_ivec2",
-                |_self: Ref<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::UVec2::as_ivec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_u64vec2",
-                |_self: Ref<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::UVec2::as_u64vec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec2",
-                |_self: Ref<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::UVec2::as_vec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::UVec2>| {
-                    let output: () = <bevy::math::UVec2 as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp",
-                |
-                    _self: Val<bevy::math::UVec2>,
-                    min: Val<bevy::math::UVec2>,
-                    max: Val<bevy::math::UVec2>|
-                {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::clamp(
-                            _self.into_inner(),
-                            min.into_inner(),
-                            max.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpeq",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::UVec2::cmpeq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpge",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::UVec2::cmpge(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpgt",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::UVec2::cmpgt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmple",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::UVec2::cmple(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmplt",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::UVec2::cmplt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpne",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::UVec2::cmpne(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::UVec2>, rhs: Ref<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Div<
-                        &bevy::math::UVec2,
-                    >>::div(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Div<
-                        bevy::math::UVec2,
-                    >>::div(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::UVec2>, rhs: u32| {
-                    let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Div<
-                        u32,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: u32 = bevy::math::UVec2::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot_into_vec",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::dot_into_vec(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_product",
-                |_self: Val<bevy::math::UVec2>| {
-                    let output: u32 = bevy::math::UVec2::element_product(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_sum",
-                |_self: Val<bevy::math::UVec2>| {
-                    let output: u32 = bevy::math::UVec2::element_sum(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::UVec2>, other: Ref<bevy::math::UVec2>| {
-                    let output: bool = <bevy::math::UVec2 as std::cmp::PartialEq<
-                        bevy::math::UVec2,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "extend",
-                |_self: Val<bevy::math::UVec2>, z: u32| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec2::extend(
-                            _self.into_inner(),
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [u32; 2]| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::from_array(a)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::UVec2>| {
-                    let output: u32 = bevy::math::UVec2::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::max(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max_element",
-                |_self: Val<bevy::math::UVec2>| {
-                    let output: u32 = bevy::math::UVec2::max_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::min(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min_element",
-                |_self: Val<bevy::math::UVec2>| {
-                    let output: u32 = bevy::math::UVec2::min_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::UVec2>, rhs: Ref<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Mul<
-                        &bevy::math::UVec2,
-                    >>::mul(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Mul<
-                        bevy::math::UVec2,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::UVec2>, rhs: u32| {
-                    let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Mul<
-                        u32,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: u32, y: u32| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::new(x, y)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::UVec2>, rhs: Ref<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Rem<
-                        &bevy::math::UVec2,
-                    >>::rem(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Rem<
-                        bevy::math::UVec2,
-                    >>::rem(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::UVec2>, rhs: u32| {
-                    let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Rem<
-                        u32,
-                    >>::rem(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::saturating_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add_signed",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::saturating_add_signed(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_div",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::saturating_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_mul",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::saturating_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_sub",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::saturating_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "select",
-                |
-                    mask: Val<bevy::math::BVec2>,
-                    if_true: Val<bevy::math::UVec2>,
-                    if_false: Val<bevy::math::UVec2>|
-                {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::select(
-                            mask.into_inner(),
-                            if_true.into_inner(),
-                            if_false.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: u32| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::UVec2>, rhs: Ref<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Sub<
-                        &bevy::math::UVec2,
-                    >>::sub(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Sub<
-                        bevy::math::UVec2,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::UVec2>, rhs: u32| {
-                    let output: Val<bevy::math::UVec2> = <bevy::math::UVec2 as std::ops::Sub<
-                        u32,
-                    >>::sub(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::UVec2>| {
-                    let output: [u32; 2] = bevy::math::UVec2::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "with_x",
-                |_self: Val<bevy::math::UVec2>, x: u32| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::with_x(
-                            _self.into_inner(),
-                            x,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_y",
-                |_self: Val<bevy::math::UVec2>, y: u32| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::with_y(
-                            _self.into_inner(),
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::wrapping_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add_signed",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::IVec2>| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::wrapping_add_signed(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_div",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::wrapping_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_mul",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::wrapping_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_sub",
-                |_self: Val<bevy::math::UVec2>, rhs: Val<bevy::math::UVec2>| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec2::wrapping_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::UVec3>::new(world)
-            .register(
-                "add",
-                |_self: Val<bevy::math::UVec3>, rhs: Ref<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Add<
-                        &bevy::math::UVec3,
-                    >>::add(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Add<
-                        bevy::math::UVec3,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::UVec3>, rhs: u32| {
-                    let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Add<
-                        u32,
-                    >>::add(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dvec3",
-                |_self: Ref<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::UVec3::as_dvec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_i64vec3",
-                |_self: Ref<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::UVec3::as_i64vec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_ivec3",
-                |_self: Ref<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::UVec3::as_ivec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_u64vec3",
-                |_self: Ref<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::UVec3::as_u64vec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec3",
-                |_self: Ref<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::UVec3::as_vec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec3a",
-                |_self: Ref<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::UVec3::as_vec3a(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::UVec3>| {
-                    let output: () = <bevy::math::UVec3 as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp",
-                |
-                    _self: Val<bevy::math::UVec3>,
-                    min: Val<bevy::math::UVec3>,
-                    max: Val<bevy::math::UVec3>|
-                {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::clamp(
-                            _self.into_inner(),
-                            min.into_inner(),
-                            max.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpeq",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::UVec3::cmpeq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpge",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::UVec3::cmpge(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpgt",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::UVec3::cmpgt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmple",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::UVec3::cmple(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmplt",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::UVec3::cmplt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpne",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::UVec3::cmpne(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cross",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::cross(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::UVec3>, rhs: Ref<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Div<
-                        &bevy::math::UVec3,
-                    >>::div(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Div<
-                        bevy::math::UVec3,
-                    >>::div(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::UVec3>, rhs: u32| {
-                    let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Div<
-                        u32,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: u32 = bevy::math::UVec3::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot_into_vec",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::dot_into_vec(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_product",
-                |_self: Val<bevy::math::UVec3>| {
-                    let output: u32 = bevy::math::UVec3::element_product(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_sum",
-                |_self: Val<bevy::math::UVec3>| {
-                    let output: u32 = bevy::math::UVec3::element_sum(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::UVec3>, other: Ref<bevy::math::UVec3>| {
-                    let output: bool = <bevy::math::UVec3 as std::cmp::PartialEq<
-                        bevy::math::UVec3,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "extend",
-                |_self: Val<bevy::math::UVec3>, w: u32| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec3::extend(
-                            _self.into_inner(),
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [u32; 3]| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::from_array(a)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::UVec3>| {
-                    let output: u32 = bevy::math::UVec3::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::max(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max_element",
-                |_self: Val<bevy::math::UVec3>| {
-                    let output: u32 = bevy::math::UVec3::max_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::min(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min_element",
-                |_self: Val<bevy::math::UVec3>| {
-                    let output: u32 = bevy::math::UVec3::min_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::UVec3>, rhs: Ref<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Mul<
-                        &bevy::math::UVec3,
-                    >>::mul(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Mul<
-                        bevy::math::UVec3,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::UVec3>, rhs: u32| {
-                    let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Mul<
-                        u32,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: u32, y: u32, z: u32| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::new(x, y, z)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::UVec3>, rhs: Ref<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Rem<
-                        &bevy::math::UVec3,
-                    >>::rem(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Rem<
-                        bevy::math::UVec3,
-                    >>::rem(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::UVec3>, rhs: u32| {
-                    let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Rem<
-                        u32,
-                    >>::rem(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::saturating_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add_signed",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::saturating_add_signed(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_div",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::saturating_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_mul",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::saturating_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_sub",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::saturating_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "select",
-                |
-                    mask: Val<bevy::math::BVec3>,
-                    if_true: Val<bevy::math::UVec3>,
-                    if_false: Val<bevy::math::UVec3>|
-                {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::select(
-                            mask.into_inner(),
-                            if_true.into_inner(),
-                            if_false.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: u32| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::UVec3>, rhs: Ref<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Sub<
-                        &bevy::math::UVec3,
-                    >>::sub(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Sub<
-                        bevy::math::UVec3,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::UVec3>, rhs: u32| {
-                    let output: Val<bevy::math::UVec3> = <bevy::math::UVec3 as std::ops::Sub<
-                        u32,
-                    >>::sub(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::UVec3>| {
-                    let output: [u32; 3] = bevy::math::UVec3::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "truncate",
-                |_self: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::UVec3::truncate(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_x",
-                |_self: Val<bevy::math::UVec3>, x: u32| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::with_x(
-                            _self.into_inner(),
-                            x,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_y",
-                |_self: Val<bevy::math::UVec3>, y: u32| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::with_y(
-                            _self.into_inner(),
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_z",
-                |_self: Val<bevy::math::UVec3>, z: u32| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::with_z(
-                            _self.into_inner(),
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::wrapping_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add_signed",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::IVec3>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::wrapping_add_signed(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_div",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::wrapping_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_mul",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::wrapping_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_sub",
-                |_self: Val<bevy::math::UVec3>, rhs: Val<bevy::math::UVec3>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec3::wrapping_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::UVec4>::new(world)
-            .register(
-                "add",
-                |_self: Val<bevy::math::UVec4>, rhs: Ref<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Add<
-                        &bevy::math::UVec4,
-                    >>::add(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Add<
-                        bevy::math::UVec4,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::UVec4>, rhs: u32| {
-                    let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Add<
-                        u32,
-                    >>::add(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dvec4",
-                |_self: Ref<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::UVec4::as_dvec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_i64vec4",
-                |_self: Ref<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::UVec4::as_i64vec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_ivec4",
-                |_self: Ref<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::UVec4::as_ivec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_u64vec4",
-                |_self: Ref<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::UVec4::as_u64vec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec4",
-                |_self: Ref<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::UVec4::as_vec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::UVec4>| {
-                    let output: () = <bevy::math::UVec4 as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp",
-                |
-                    _self: Val<bevy::math::UVec4>,
-                    min: Val<bevy::math::UVec4>,
-                    max: Val<bevy::math::UVec4>|
-                {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::clamp(
-                            _self.into_inner(),
-                            min.into_inner(),
-                            max.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpeq",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::UVec4::cmpeq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpge",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::UVec4::cmpge(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpgt",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::UVec4::cmpgt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmple",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::UVec4::cmple(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmplt",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::UVec4::cmplt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpne",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::UVec4::cmpne(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::UVec4>, rhs: Ref<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Div<
-                        &bevy::math::UVec4,
-                    >>::div(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Div<
-                        bevy::math::UVec4,
-                    >>::div(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::UVec4>, rhs: u32| {
-                    let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Div<
-                        u32,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: u32 = bevy::math::UVec4::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot_into_vec",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::dot_into_vec(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_product",
-                |_self: Val<bevy::math::UVec4>| {
-                    let output: u32 = bevy::math::UVec4::element_product(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_sum",
-                |_self: Val<bevy::math::UVec4>| {
-                    let output: u32 = bevy::math::UVec4::element_sum(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::UVec4>, other: Ref<bevy::math::UVec4>| {
-                    let output: bool = <bevy::math::UVec4 as std::cmp::PartialEq<
-                        bevy::math::UVec4,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [u32; 4]| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::from_array(a)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::UVec4>| {
-                    let output: u32 = bevy::math::UVec4::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::max(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max_element",
-                |_self: Val<bevy::math::UVec4>| {
-                    let output: u32 = bevy::math::UVec4::max_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::min(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min_element",
-                |_self: Val<bevy::math::UVec4>| {
-                    let output: u32 = bevy::math::UVec4::min_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::UVec4>, rhs: Ref<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Mul<
-                        &bevy::math::UVec4,
-                    >>::mul(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Mul<
-                        bevy::math::UVec4,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::UVec4>, rhs: u32| {
-                    let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Mul<
-                        u32,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: u32, y: u32, z: u32, w: u32| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::new(
-                            x,
-                            y,
-                            z,
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::UVec4>, rhs: Ref<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Rem<
-                        &bevy::math::UVec4,
-                    >>::rem(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Rem<
-                        bevy::math::UVec4,
-                    >>::rem(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::UVec4>, rhs: u32| {
-                    let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Rem<
-                        u32,
-                    >>::rem(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::saturating_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add_signed",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::saturating_add_signed(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_div",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::saturating_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_mul",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::saturating_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_sub",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::saturating_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "select",
-                |
-                    mask: Val<bevy::math::BVec4>,
-                    if_true: Val<bevy::math::UVec4>,
-                    if_false: Val<bevy::math::UVec4>|
-                {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::select(
-                            mask.into_inner(),
-                            if_true.into_inner(),
-                            if_false.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: u32| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::UVec4>, rhs: Ref<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Sub<
-                        &bevy::math::UVec4,
-                    >>::sub(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Sub<
-                        bevy::math::UVec4,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::UVec4>, rhs: u32| {
-                    let output: Val<bevy::math::UVec4> = <bevy::math::UVec4 as std::ops::Sub<
-                        u32,
-                    >>::sub(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::UVec4>| {
-                    let output: [u32; 4] = bevy::math::UVec4::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "truncate",
-                |_self: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::UVec4::truncate(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_w",
-                |_self: Val<bevy::math::UVec4>, w: u32| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::with_w(
-                            _self.into_inner(),
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_x",
-                |_self: Val<bevy::math::UVec4>, x: u32| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::with_x(
-                            _self.into_inner(),
-                            x,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_y",
-                |_self: Val<bevy::math::UVec4>, y: u32| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::with_y(
-                            _self.into_inner(),
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_z",
-                |_self: Val<bevy::math::UVec4>, z: u32| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::with_z(
-                            _self.into_inner(),
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::wrapping_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add_signed",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::IVec4>| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::wrapping_add_signed(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_div",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::wrapping_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_mul",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::wrapping_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_sub",
-                |_self: Val<bevy::math::UVec4>, rhs: Val<bevy::math::UVec4>| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::UVec4::wrapping_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::U64Vec2>::new(world)
-            .register(
-                "add",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Ref<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Add<
-                        &bevy::math::U64Vec2,
-                    >>::add(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Add<
-                        bevy::math::U64Vec2,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::U64Vec2>, rhs: u64| {
-                    let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Add<
-                        u64,
-                    >>::add(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dvec2",
-                |_self: Ref<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::U64Vec2::as_dvec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_i64vec2",
-                |_self: Ref<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::U64Vec2::as_i64vec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_ivec2",
-                |_self: Ref<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::U64Vec2::as_ivec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_uvec2",
-                |_self: Ref<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::U64Vec2::as_uvec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec2",
-                |_self: Ref<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::U64Vec2::as_vec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::U64Vec2>| {
-                    let output: () = <bevy::math::U64Vec2 as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp",
-                |
-                    _self: Val<bevy::math::U64Vec2>,
-                    min: Val<bevy::math::U64Vec2>,
-                    max: Val<bevy::math::U64Vec2>|
-                {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::clamp(
-                            _self.into_inner(),
-                            min.into_inner(),
-                            max.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpeq",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::U64Vec2::cmpeq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpge",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::U64Vec2::cmpge(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpgt",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::U64Vec2::cmpgt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmple",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::U64Vec2::cmple(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmplt",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::U64Vec2::cmplt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpne",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::U64Vec2::cmpne(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Ref<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Div<
-                        &bevy::math::U64Vec2,
-                    >>::div(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Div<
-                        bevy::math::U64Vec2,
-                    >>::div(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::U64Vec2>, rhs: u64| {
-                    let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Div<
-                        u64,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: u64 = bevy::math::U64Vec2::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot_into_vec",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::dot_into_vec(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_product",
-                |_self: Val<bevy::math::U64Vec2>| {
-                    let output: u64 = bevy::math::U64Vec2::element_product(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_sum",
-                |_self: Val<bevy::math::U64Vec2>| {
-                    let output: u64 = bevy::math::U64Vec2::element_sum(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::U64Vec2>, other: Ref<bevy::math::U64Vec2>| {
-                    let output: bool = <bevy::math::U64Vec2 as std::cmp::PartialEq<
-                        bevy::math::U64Vec2,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "extend",
-                |_self: Val<bevy::math::U64Vec2>, z: u64| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec2::extend(
-                            _self.into_inner(),
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [u64; 2]| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::from_array(
-                            a,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::U64Vec2>| {
-                    let output: u64 = bevy::math::U64Vec2::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::max(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max_element",
-                |_self: Val<bevy::math::U64Vec2>| {
-                    let output: u64 = bevy::math::U64Vec2::max_element(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::min(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min_element",
-                |_self: Val<bevy::math::U64Vec2>| {
-                    let output: u64 = bevy::math::U64Vec2::min_element(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Ref<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Mul<
-                        &bevy::math::U64Vec2,
-                    >>::mul(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Mul<
-                        bevy::math::U64Vec2,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::U64Vec2>, rhs: u64| {
-                    let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Mul<
-                        u64,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: u64, y: u64| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::new(x, y)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Ref<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Rem<
-                        &bevy::math::U64Vec2,
-                    >>::rem(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Rem<
-                        bevy::math::U64Vec2,
-                    >>::rem(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::U64Vec2>, rhs: u64| {
-                    let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Rem<
-                        u64,
-                    >>::rem(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::saturating_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add_signed",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::saturating_add_signed(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_div",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::saturating_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_mul",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::saturating_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_sub",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::saturating_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "select",
-                |
-                    mask: Val<bevy::math::BVec2>,
-                    if_true: Val<bevy::math::U64Vec2>,
-                    if_false: Val<bevy::math::U64Vec2>|
-                {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::select(
-                            mask.into_inner(),
-                            if_true.into_inner(),
-                            if_false.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: u64| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Ref<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Sub<
-                        &bevy::math::U64Vec2,
-                    >>::sub(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Sub<
-                        bevy::math::U64Vec2,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::U64Vec2>, rhs: u64| {
-                    let output: Val<bevy::math::U64Vec2> = <bevy::math::U64Vec2 as std::ops::Sub<
-                        u64,
-                    >>::sub(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::U64Vec2>| {
-                    let output: [u64; 2] = bevy::math::U64Vec2::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "with_x",
-                |_self: Val<bevy::math::U64Vec2>, x: u64| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::with_x(
-                            _self.into_inner(),
-                            x,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_y",
-                |_self: Val<bevy::math::U64Vec2>, y: u64| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::with_y(
-                            _self.into_inner(),
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::wrapping_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add_signed",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::I64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::wrapping_add_signed(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_div",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::wrapping_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_mul",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::wrapping_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_sub",
-                |_self: Val<bevy::math::U64Vec2>, rhs: Val<bevy::math::U64Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec2::wrapping_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::U64Vec3>::new(world)
-            .register(
-                "add",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Ref<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Add<
-                        &bevy::math::U64Vec3,
-                    >>::add(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Add<
-                        bevy::math::U64Vec3,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::U64Vec3>, rhs: u64| {
-                    let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Add<
-                        u64,
-                    >>::add(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dvec3",
-                |_self: Ref<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::U64Vec3::as_dvec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_i64vec3",
-                |_self: Ref<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::U64Vec3::as_i64vec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_ivec3",
-                |_self: Ref<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::U64Vec3::as_ivec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_uvec3",
-                |_self: Ref<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::U64Vec3::as_uvec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec3",
-                |_self: Ref<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::U64Vec3::as_vec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec3a",
-                |_self: Ref<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::U64Vec3::as_vec3a(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::U64Vec3>| {
-                    let output: () = <bevy::math::U64Vec3 as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp",
-                |
-                    _self: Val<bevy::math::U64Vec3>,
-                    min: Val<bevy::math::U64Vec3>,
-                    max: Val<bevy::math::U64Vec3>|
-                {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::clamp(
-                            _self.into_inner(),
-                            min.into_inner(),
-                            max.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpeq",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::U64Vec3::cmpeq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpge",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::U64Vec3::cmpge(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpgt",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::U64Vec3::cmpgt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmple",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::U64Vec3::cmple(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmplt",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::U64Vec3::cmplt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpne",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::U64Vec3::cmpne(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cross",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::cross(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Ref<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Div<
-                        &bevy::math::U64Vec3,
-                    >>::div(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Div<
-                        bevy::math::U64Vec3,
-                    >>::div(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::U64Vec3>, rhs: u64| {
-                    let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Div<
-                        u64,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: u64 = bevy::math::U64Vec3::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot_into_vec",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::dot_into_vec(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_product",
-                |_self: Val<bevy::math::U64Vec3>| {
-                    let output: u64 = bevy::math::U64Vec3::element_product(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_sum",
-                |_self: Val<bevy::math::U64Vec3>| {
-                    let output: u64 = bevy::math::U64Vec3::element_sum(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::U64Vec3>, other: Ref<bevy::math::U64Vec3>| {
-                    let output: bool = <bevy::math::U64Vec3 as std::cmp::PartialEq<
-                        bevy::math::U64Vec3,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "extend",
-                |_self: Val<bevy::math::U64Vec3>, w: u64| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec3::extend(
-                            _self.into_inner(),
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [u64; 3]| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::from_array(
-                            a,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::U64Vec3>| {
-                    let output: u64 = bevy::math::U64Vec3::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::max(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max_element",
-                |_self: Val<bevy::math::U64Vec3>| {
-                    let output: u64 = bevy::math::U64Vec3::max_element(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::min(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min_element",
-                |_self: Val<bevy::math::U64Vec3>| {
-                    let output: u64 = bevy::math::U64Vec3::min_element(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Ref<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Mul<
-                        &bevy::math::U64Vec3,
-                    >>::mul(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Mul<
-                        bevy::math::U64Vec3,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::U64Vec3>, rhs: u64| {
-                    let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Mul<
-                        u64,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: u64, y: u64, z: u64| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::new(
-                            x,
-                            y,
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Ref<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Rem<
-                        &bevy::math::U64Vec3,
-                    >>::rem(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Rem<
-                        bevy::math::U64Vec3,
-                    >>::rem(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::U64Vec3>, rhs: u64| {
-                    let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Rem<
-                        u64,
-                    >>::rem(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::saturating_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add_signed",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::saturating_add_signed(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_div",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::saturating_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_mul",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::saturating_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_sub",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::saturating_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "select",
-                |
-                    mask: Val<bevy::math::BVec3>,
-                    if_true: Val<bevy::math::U64Vec3>,
-                    if_false: Val<bevy::math::U64Vec3>|
-                {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::select(
-                            mask.into_inner(),
-                            if_true.into_inner(),
-                            if_false.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: u64| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Ref<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Sub<
-                        &bevy::math::U64Vec3,
-                    >>::sub(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Sub<
-                        bevy::math::U64Vec3,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::U64Vec3>, rhs: u64| {
-                    let output: Val<bevy::math::U64Vec3> = <bevy::math::U64Vec3 as std::ops::Sub<
-                        u64,
-                    >>::sub(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::U64Vec3>| {
-                    let output: [u64; 3] = bevy::math::U64Vec3::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "truncate",
-                |_self: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::U64Vec3::truncate(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_x",
-                |_self: Val<bevy::math::U64Vec3>, x: u64| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::with_x(
-                            _self.into_inner(),
-                            x,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_y",
-                |_self: Val<bevy::math::U64Vec3>, y: u64| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::with_y(
-                            _self.into_inner(),
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_z",
-                |_self: Val<bevy::math::U64Vec3>, z: u64| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::with_z(
-                            _self.into_inner(),
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::wrapping_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add_signed",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::I64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::wrapping_add_signed(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_div",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::wrapping_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_mul",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::wrapping_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_sub",
-                |_self: Val<bevy::math::U64Vec3>, rhs: Val<bevy::math::U64Vec3>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec3::wrapping_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::U64Vec4>::new(world)
-            .register(
-                "add",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Ref<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Add<
-                        &bevy::math::U64Vec4,
-                    >>::add(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Add<
-                        bevy::math::U64Vec4,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::U64Vec4>, rhs: u64| {
-                    let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Add<
-                        u64,
-                    >>::add(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dvec4",
-                |_self: Ref<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::U64Vec4::as_dvec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_i64vec4",
-                |_self: Ref<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::U64Vec4::as_i64vec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_ivec4",
-                |_self: Ref<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::U64Vec4::as_ivec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_uvec4",
-                |_self: Ref<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::U64Vec4::as_uvec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec4",
-                |_self: Ref<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::U64Vec4::as_vec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::U64Vec4>| {
-                    let output: () = <bevy::math::U64Vec4 as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp",
-                |
-                    _self: Val<bevy::math::U64Vec4>,
-                    min: Val<bevy::math::U64Vec4>,
-                    max: Val<bevy::math::U64Vec4>|
-                {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::clamp(
-                            _self.into_inner(),
-                            min.into_inner(),
-                            max.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpeq",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::U64Vec4::cmpeq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpge",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::U64Vec4::cmpge(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpgt",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::U64Vec4::cmpgt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmple",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::U64Vec4::cmple(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmplt",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::U64Vec4::cmplt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpne",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::U64Vec4::cmpne(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Ref<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Div<
-                        &bevy::math::U64Vec4,
-                    >>::div(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Div<
-                        bevy::math::U64Vec4,
-                    >>::div(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::U64Vec4>, rhs: u64| {
-                    let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Div<
-                        u64,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: u64 = bevy::math::U64Vec4::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot_into_vec",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::dot_into_vec(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_product",
-                |_self: Val<bevy::math::U64Vec4>| {
-                    let output: u64 = bevy::math::U64Vec4::element_product(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_sum",
-                |_self: Val<bevy::math::U64Vec4>| {
-                    let output: u64 = bevy::math::U64Vec4::element_sum(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::U64Vec4>, other: Ref<bevy::math::U64Vec4>| {
-                    let output: bool = <bevy::math::U64Vec4 as std::cmp::PartialEq<
-                        bevy::math::U64Vec4,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [u64; 4]| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::from_array(
-                            a,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::U64Vec4>| {
-                    let output: u64 = bevy::math::U64Vec4::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::max(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max_element",
-                |_self: Val<bevy::math::U64Vec4>| {
-                    let output: u64 = bevy::math::U64Vec4::max_element(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::min(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min_element",
-                |_self: Val<bevy::math::U64Vec4>| {
-                    let output: u64 = bevy::math::U64Vec4::min_element(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Ref<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Mul<
-                        &bevy::math::U64Vec4,
-                    >>::mul(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Mul<
-                        bevy::math::U64Vec4,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::U64Vec4>, rhs: u64| {
-                    let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Mul<
-                        u64,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: u64, y: u64, z: u64, w: u64| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::new(
-                            x,
-                            y,
-                            z,
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Ref<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Rem<
-                        &bevy::math::U64Vec4,
-                    >>::rem(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Rem<
-                        bevy::math::U64Vec4,
-                    >>::rem(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::U64Vec4>, rhs: u64| {
-                    let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Rem<
-                        u64,
-                    >>::rem(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::saturating_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_add_signed",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::saturating_add_signed(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_div",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::saturating_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_mul",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::saturating_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "saturating_sub",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::saturating_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "select",
-                |
-                    mask: Val<bevy::math::BVec4>,
-                    if_true: Val<bevy::math::U64Vec4>,
-                    if_false: Val<bevy::math::U64Vec4>|
-                {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::select(
-                            mask.into_inner(),
-                            if_true.into_inner(),
-                            if_false.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: u64| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Ref<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Sub<
-                        &bevy::math::U64Vec4,
-                    >>::sub(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Sub<
-                        bevy::math::U64Vec4,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::U64Vec4>, rhs: u64| {
-                    let output: Val<bevy::math::U64Vec4> = <bevy::math::U64Vec4 as std::ops::Sub<
-                        u64,
-                    >>::sub(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::U64Vec4>| {
-                    let output: [u64; 4] = bevy::math::U64Vec4::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "truncate",
-                |_self: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::U64Vec4::truncate(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_w",
-                |_self: Val<bevy::math::U64Vec4>, w: u64| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::with_w(
-                            _self.into_inner(),
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_x",
-                |_self: Val<bevy::math::U64Vec4>, x: u64| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::with_x(
-                            _self.into_inner(),
-                            x,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_y",
-                |_self: Val<bevy::math::U64Vec4>, y: u64| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::with_y(
-                            _self.into_inner(),
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_z",
-                |_self: Val<bevy::math::U64Vec4>, z: u64| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::with_z(
-                            _self.into_inner(),
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::wrapping_add(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_add_signed",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::I64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::wrapping_add_signed(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_div",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::wrapping_div(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_mul",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::wrapping_mul(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "wrapping_sub",
-                |_self: Val<bevy::math::U64Vec4>, rhs: Val<bevy::math::U64Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::U64Vec4::wrapping_sub(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::Vec2>::new(world)
-            .register(
-                "abs",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::abs(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Val<bevy::math::Vec2>,
-                    rhs: Val<bevy::math::Vec2>,
-                    max_abs_diff: f32|
-                {
-                    let output: bool = bevy::math::Vec2::abs_diff_eq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::Vec2>, rhs: Ref<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Add<
-                        &bevy::math::Vec2,
-                    >>::add(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Add<
-                        bevy::math::Vec2,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::Vec2>, rhs: f32| {
-                    let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Add<
-                        f32,
-                    >>::add(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "angle_between",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: f32 = bevy::math::Vec2::angle_between(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "angle_to",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: f32 = bevy::math::Vec2::angle_to(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dvec2",
-                |_self: Ref<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::Vec2::as_dvec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_i64vec2",
-                |_self: Ref<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::Vec2::as_i64vec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_ivec2",
-                |_self: Ref<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::Vec2::as_ivec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_u64vec2",
-                |_self: Ref<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::Vec2::as_u64vec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_uvec2",
-                |_self: Ref<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::Vec2::as_uvec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "ceil",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::ceil(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp",
-                |
-                    _self: Val<bevy::math::Vec2>,
-                    min: Val<bevy::math::Vec2>,
-                    max: Val<bevy::math::Vec2>|
-                {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::clamp(
-                            _self.into_inner(),
-                            min.into_inner(),
-                            max.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length",
-                |_self: Val<bevy::math::Vec2>, min: f32, max: f32| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::clamp_length(
-                            _self.into_inner(),
-                            min,
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length_max",
-                |_self: Val<bevy::math::Vec2>, max: f32| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::clamp_length_max(
-                            _self.into_inner(),
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length_min",
-                |_self: Val<bevy::math::Vec2>, min: f32| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::clamp_length_min(
-                            _self.into_inner(),
-                            min,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpeq",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::Vec2::cmpeq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpge",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::Vec2::cmpge(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpgt",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::Vec2::cmpgt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmple",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::Vec2::cmple(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmplt",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::Vec2::cmplt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpne",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::Vec2::cmpne(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "copysign",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::copysign(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: f32 = bevy::math::Vec2::distance(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance_squared",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: f32 = bevy::math::Vec2::distance_squared(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::Vec2>, rhs: Ref<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Div<
-                        &bevy::math::Vec2,
-                    >>::div(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Div<
-                        bevy::math::Vec2,
-                    >>::div(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::Vec2>, rhs: f32| {
-                    let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Div<
-                        f32,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_euclid",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::div_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: f32 = bevy::math::Vec2::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot_into_vec",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::dot_into_vec(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_product",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: f32 = bevy::math::Vec2::element_product(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_sum",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: f32 = bevy::math::Vec2::element_sum(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::Vec2>, other: Ref<bevy::math::Vec2>| {
-                    let output: bool = <bevy::math::Vec2 as std::cmp::PartialEq<
-                        bevy::math::Vec2,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "exp",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::exp(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "extend",
-                |_self: Val<bevy::math::Vec2>, z: f32| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec2::extend(
-                            _self.into_inner(),
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "floor",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::floor(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fract",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::fract(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fract_gl",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::fract_gl(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_angle",
-                |angle: f32| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::from_angle(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [f32; 2]| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::from_array(a)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: bool = bevy::math::Vec2::is_finite(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite_mask",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::Vec2::is_finite_mask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: bool = bevy::math::Vec2::is_nan(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_nan_mask",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::Vec2::is_nan_mask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_negative_bitmask",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: u32 = bevy::math::Vec2::is_negative_bitmask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_normalized",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: bool = bevy::math::Vec2::is_normalized(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: f32 = bevy::math::Vec2::length(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_recip",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: f32 = bevy::math::Vec2::length_recip(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: f32 = bevy::math::Vec2::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "lerp",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>, s: f32| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::lerp(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                            s,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::max(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max_element",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: f32 = bevy::math::Vec2::max_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "midpoint",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::midpoint(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::min(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min_element",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: f32 = bevy::math::Vec2::min_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "move_towards",
-                |_self: Ref<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>, d: f32| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::move_towards(
-                            &_self,
-                            rhs.into_inner(),
-                            d,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Vec2>, rhs: Ref<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Mul<
-                        &bevy::math::Vec2,
-                    >>::mul(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Mul<
-                        bevy::math::Vec2,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Vec2>, rhs: f32| {
-                    let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Mul<
-                        f32,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_add",
-                |
-                    _self: Val<bevy::math::Vec2>,
-                    a: Val<bevy::math::Vec2>,
-                    b: Val<bevy::math::Vec2>|
-                {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::mul_add(
-                            _self.into_inner(),
-                            a.into_inner(),
-                            b.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: f32, y: f32| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::new(x, y)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::normalize(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize_or",
-                |_self: Val<bevy::math::Vec2>, fallback: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::normalize_or(
-                            _self.into_inner(),
-                            fallback.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize_or_zero",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::normalize_or_zero(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perp",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::perp(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perp_dot",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: f32 = bevy::math::Vec2::perp_dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "powf",
-                |_self: Val<bevy::math::Vec2>, n: f32| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::powf(
-                            _self.into_inner(),
-                            n,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "project_onto",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::project_onto(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "project_onto_normalized",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::project_onto_normalized(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "recip",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::recip(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reflect",
-                |_self: Val<bevy::math::Vec2>, normal: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::reflect(
-                            _self.into_inner(),
-                            normal.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "refract",
-                |_self: Val<bevy::math::Vec2>, normal: Val<bevy::math::Vec2>, eta: f32| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::refract(
-                            _self.into_inner(),
-                            normal.into_inner(),
-                            eta,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reject_from",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::reject_from(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reject_from_normalized",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::reject_from_normalized(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::Vec2>, rhs: Ref<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Rem<
-                        &bevy::math::Vec2,
-                    >>::rem(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Rem<
-                        bevy::math::Vec2,
-                    >>::rem(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::Vec2>, rhs: f32| {
-                    let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Rem<
-                        f32,
-                    >>::rem(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem_euclid",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::rem_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotate",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::rotate(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotate_towards",
-                |
-                    _self: Ref<bevy::math::Vec2>,
-                    rhs: Val<bevy::math::Vec2>,
-                    max_angle: f32|
-                {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::rotate_towards(
-                            &_self,
-                            rhs.into_inner(),
-                            max_angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "round",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::round(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "select",
-                |
-                    mask: Val<bevy::math::BVec2>,
-                    if_true: Val<bevy::math::Vec2>,
-                    if_false: Val<bevy::math::Vec2>|
-                {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::select(
-                            mask.into_inner(),
-                            if_true.into_inner(),
-                            if_false.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "signum",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::signum(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: f32| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::Vec2>, rhs: Ref<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Sub<
-                        &bevy::math::Vec2,
-                    >>::sub(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::Vec2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Sub<
-                        bevy::math::Vec2,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::Vec2>, rhs: f32| {
-                    let output: Val<bevy::math::Vec2> = <bevy::math::Vec2 as std::ops::Sub<
-                        f32,
-                    >>::sub(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_angle",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: f32 = bevy::math::Vec2::to_angle(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::Vec2>| {
-                    let output: [f32; 2] = bevy::math::Vec2::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "trunc",
-                |_self: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::trunc(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_x",
-                |_self: Val<bevy::math::Vec2>, x: f32| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::with_x(
-                            _self.into_inner(),
-                            x,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_y",
-                |_self: Val<bevy::math::Vec2>, y: f32| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec2::with_y(
-                            _self.into_inner(),
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::Vec3A>::new(world)
-            .register(
-                "abs",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::abs(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Val<bevy::math::Vec3A>,
-                    rhs: Val<bevy::math::Vec3A>,
-                    max_abs_diff: f32|
-                {
-                    let output: bool = bevy::math::Vec3A::abs_diff_eq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::Vec3A>, rhs: Ref<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Add<
-                        &bevy::math::Vec3A,
-                    >>::add(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Add<
-                        bevy::math::Vec3A,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::Vec3A>, rhs: f32| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Add<
-                        f32,
-                    >>::add(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "angle_between",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: f32 = bevy::math::Vec3A::angle_between(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "any_orthogonal_vector",
-                |_self: Ref<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::any_orthogonal_vector(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "any_orthonormal_vector",
-                |_self: Ref<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::any_orthonormal_vector(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dvec3",
-                |_self: Ref<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::Vec3A::as_dvec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_i64vec3",
-                |_self: Ref<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::Vec3A::as_i64vec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_ivec3",
-                |_self: Ref<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::Vec3A::as_ivec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_u64vec3",
-                |_self: Ref<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::Vec3A::as_u64vec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_uvec3",
-                |_self: Ref<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::Vec3A::as_uvec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "ceil",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::ceil(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp",
-                |
-                    _self: Val<bevy::math::Vec3A>,
-                    min: Val<bevy::math::Vec3A>,
-                    max: Val<bevy::math::Vec3A>|
-                {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::clamp(
-                            _self.into_inner(),
-                            min.into_inner(),
-                            max.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length",
-                |_self: Val<bevy::math::Vec3A>, min: f32, max: f32| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::clamp_length(
-                            _self.into_inner(),
-                            min,
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length_max",
-                |_self: Val<bevy::math::Vec3A>, max: f32| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::clamp_length_max(
-                            _self.into_inner(),
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length_min",
-                |_self: Val<bevy::math::Vec3A>, min: f32| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::clamp_length_min(
-                            _self.into_inner(),
-                            min,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpeq",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::BVec3A> = bevy::math::Vec3A::cmpeq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpge",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::BVec3A> = bevy::math::Vec3A::cmpge(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpgt",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::BVec3A> = bevy::math::Vec3A::cmpgt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmple",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::BVec3A> = bevy::math::Vec3A::cmple(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmplt",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::BVec3A> = bevy::math::Vec3A::cmplt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpne",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::BVec3A> = bevy::math::Vec3A::cmpne(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "copysign",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::copysign(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cross",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::cross(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: f32 = bevy::math::Vec3A::distance(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance_squared",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: f32 = bevy::math::Vec3A::distance_squared(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::Vec3A>, rhs: Ref<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Div<
-                        &bevy::math::Vec3A,
-                    >>::div(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Div<
-                        bevy::math::Vec3A,
-                    >>::div(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::Vec3A>, rhs: f32| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Div<
-                        f32,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_euclid",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::div_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: f32 = bevy::math::Vec3A::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot_into_vec",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::dot_into_vec(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_product",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: f32 = bevy::math::Vec3A::element_product(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_sum",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: f32 = bevy::math::Vec3A::element_sum(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::Vec3A>, rhs: Ref<bevy::math::Vec3A>| {
-                    let output: bool = <bevy::math::Vec3A as std::cmp::PartialEq<
-                        bevy::math::Vec3A,
-                    >>::eq(&_self, &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "exp",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::exp(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "extend",
-                |_self: Val<bevy::math::Vec3A>, w: f32| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec3A::extend(
-                            _self.into_inner(),
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "floor",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::floor(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fract",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::fract(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fract_gl",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::fract_gl(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [f32; 3]| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::from_array(a)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_vec4",
-                |v: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::from_vec4(
-                            v.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: bool = bevy::math::Vec3A::is_finite(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite_mask",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::BVec3A> = bevy::math::Vec3A::is_finite_mask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: bool = bevy::math::Vec3A::is_nan(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_nan_mask",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::BVec3A> = bevy::math::Vec3A::is_nan_mask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_negative_bitmask",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: u32 = bevy::math::Vec3A::is_negative_bitmask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_normalized",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: bool = bevy::math::Vec3A::is_normalized(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: f32 = bevy::math::Vec3A::length(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_recip",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: f32 = bevy::math::Vec3A::length_recip(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: f32 = bevy::math::Vec3A::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "lerp",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>, s: f32| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::lerp(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                            s,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::max(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max_element",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: f32 = bevy::math::Vec3A::max_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "midpoint",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::midpoint(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::min(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min_element",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: f32 = bevy::math::Vec3A::min_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "move_towards",
-                |_self: Ref<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>, d: f32| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::move_towards(
-                            &_self,
-                            rhs.into_inner(),
-                            d,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Vec3A>, rhs: Ref<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Mul<
-                        &bevy::math::Vec3A,
-                    >>::mul(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Mul<
-                        bevy::math::Vec3A,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Vec3A>, rhs: f32| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Mul<
-                        f32,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_add",
-                |
-                    _self: Val<bevy::math::Vec3A>,
-                    a: Val<bevy::math::Vec3A>,
-                    b: Val<bevy::math::Vec3A>|
-                {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::mul_add(
-                            _self.into_inner(),
-                            a.into_inner(),
-                            b.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: f32, y: f32, z: f32| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::new(x, y, z)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::normalize(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize_or",
-                |_self: Val<bevy::math::Vec3A>, fallback: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::normalize_or(
-                            _self.into_inner(),
-                            fallback.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize_or_zero",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::normalize_or_zero(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "powf",
-                |_self: Val<bevy::math::Vec3A>, n: f32| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::powf(
-                            _self.into_inner(),
-                            n,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "project_onto",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::project_onto(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "project_onto_normalized",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::project_onto_normalized(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "recip",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::recip(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reflect",
-                |_self: Val<bevy::math::Vec3A>, normal: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::reflect(
-                            _self.into_inner(),
-                            normal.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "refract",
-                |
-                    _self: Val<bevy::math::Vec3A>,
-                    normal: Val<bevy::math::Vec3A>,
-                    eta: f32|
-                {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::refract(
-                            _self.into_inner(),
-                            normal.into_inner(),
-                            eta,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reject_from",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::reject_from(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reject_from_normalized",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::reject_from_normalized(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::Vec3A>, rhs: Ref<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Rem<
-                        &bevy::math::Vec3A,
-                    >>::rem(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Rem<
-                        bevy::math::Vec3A,
-                    >>::rem(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::Vec3A>, rhs: f32| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Rem<
-                        f32,
-                    >>::rem(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem_euclid",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::rem_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "round",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::round(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "select",
-                |
-                    mask: Val<bevy::math::BVec3A>,
-                    if_true: Val<bevy::math::Vec3A>,
-                    if_false: Val<bevy::math::Vec3A>|
-                {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::select(
-                            mask.into_inner(),
-                            if_true.into_inner(),
-                            if_false.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "signum",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::signum(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: f32| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::Vec3A>, rhs: Ref<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Sub<
-                        &bevy::math::Vec3A,
-                    >>::sub(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::Vec3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Sub<
-                        bevy::math::Vec3A,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::Vec3A>, rhs: f32| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Vec3A as std::ops::Sub<
-                        f32,
-                    >>::sub(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::Vec3A>| {
-                    let output: [f32; 3] = bevy::math::Vec3A::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "trunc",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::trunc(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "truncate",
-                |_self: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Vec3A::truncate(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_x",
-                |_self: Val<bevy::math::Vec3A>, x: f32| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::with_x(
-                            _self.into_inner(),
-                            x,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_y",
-                |_self: Val<bevy::math::Vec3A>, y: f32| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::with_y(
-                            _self.into_inner(),
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_z",
-                |_self: Val<bevy::math::Vec3A>, z: f32| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Vec3A::with_z(
-                            _self.into_inner(),
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::Vec4>::new(world)
-            .register(
-                "abs",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::abs(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Val<bevy::math::Vec4>,
-                    rhs: Val<bevy::math::Vec4>,
-                    max_abs_diff: f32|
-                {
-                    let output: bool = bevy::math::Vec4::abs_diff_eq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::Vec4>, rhs: Ref<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Add<
-                        &bevy::math::Vec4,
-                    >>::add(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Add<
-                        bevy::math::Vec4,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::Vec4>, rhs: f32| {
-                    let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Add<
-                        f32,
-                    >>::add(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dvec4",
-                |_self: Ref<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::Vec4::as_dvec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_i64vec4",
-                |_self: Ref<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::Vec4::as_i64vec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_ivec4",
-                |_self: Ref<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::Vec4::as_ivec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_u64vec4",
-                |_self: Ref<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::Vec4::as_u64vec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_uvec4",
-                |_self: Ref<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::Vec4::as_uvec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "ceil",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::ceil(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp",
-                |
-                    _self: Val<bevy::math::Vec4>,
-                    min: Val<bevy::math::Vec4>,
-                    max: Val<bevy::math::Vec4>|
-                {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::clamp(
-                            _self.into_inner(),
-                            min.into_inner(),
-                            max.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length",
-                |_self: Val<bevy::math::Vec4>, min: f32, max: f32| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::clamp_length(
-                            _self.into_inner(),
-                            min,
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length_max",
-                |_self: Val<bevy::math::Vec4>, max: f32| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::clamp_length_max(
-                            _self.into_inner(),
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length_min",
-                |_self: Val<bevy::math::Vec4>, min: f32| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::clamp_length_min(
-                            _self.into_inner(),
-                            min,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpeq",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::BVec4A> = bevy::math::Vec4::cmpeq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpge",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::BVec4A> = bevy::math::Vec4::cmpge(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpgt",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::BVec4A> = bevy::math::Vec4::cmpgt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmple",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::BVec4A> = bevy::math::Vec4::cmple(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmplt",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::BVec4A> = bevy::math::Vec4::cmplt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpne",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::BVec4A> = bevy::math::Vec4::cmpne(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "copysign",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::copysign(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: f32 = bevy::math::Vec4::distance(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance_squared",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: f32 = bevy::math::Vec4::distance_squared(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::Vec4>, rhs: Ref<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Div<
-                        &bevy::math::Vec4,
-                    >>::div(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Div<
-                        bevy::math::Vec4,
-                    >>::div(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::Vec4>, rhs: f32| {
-                    let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Div<
-                        f32,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_euclid",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::div_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: f32 = bevy::math::Vec4::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot_into_vec",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::dot_into_vec(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_product",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: f32 = bevy::math::Vec4::element_product(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_sum",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: f32 = bevy::math::Vec4::element_sum(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::Vec4>, rhs: Ref<bevy::math::Vec4>| {
-                    let output: bool = <bevy::math::Vec4 as std::cmp::PartialEq<
-                        bevy::math::Vec4,
-                    >>::eq(&_self, &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "exp",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::exp(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "floor",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::floor(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fract",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::fract(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fract_gl",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::fract_gl(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [f32; 4]| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::from_array(a)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: bool = bevy::math::Vec4::is_finite(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite_mask",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::BVec4A> = bevy::math::Vec4::is_finite_mask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: bool = bevy::math::Vec4::is_nan(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_nan_mask",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::BVec4A> = bevy::math::Vec4::is_nan_mask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_negative_bitmask",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: u32 = bevy::math::Vec4::is_negative_bitmask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_normalized",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: bool = bevy::math::Vec4::is_normalized(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: f32 = bevy::math::Vec4::length(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_recip",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: f32 = bevy::math::Vec4::length_recip(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: f32 = bevy::math::Vec4::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "lerp",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>, s: f32| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::lerp(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                            s,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::max(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max_element",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: f32 = bevy::math::Vec4::max_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "midpoint",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::midpoint(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::min(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min_element",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: f32 = bevy::math::Vec4::min_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "move_towards",
-                |_self: Ref<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>, d: f32| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::move_towards(
-                            &_self,
-                            rhs.into_inner(),
-                            d,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Vec4>, rhs: Ref<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Mul<
-                        &bevy::math::Vec4,
-                    >>::mul(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Mul<
-                        bevy::math::Vec4,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Vec4>, rhs: f32| {
-                    let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Mul<
-                        f32,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_add",
-                |
-                    _self: Val<bevy::math::Vec4>,
-                    a: Val<bevy::math::Vec4>,
-                    b: Val<bevy::math::Vec4>|
-                {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::mul_add(
-                            _self.into_inner(),
-                            a.into_inner(),
-                            b.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: f32, y: f32, z: f32, w: f32| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::new(x, y, z, w)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::normalize(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize_or",
-                |_self: Val<bevy::math::Vec4>, fallback: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::normalize_or(
-                            _self.into_inner(),
-                            fallback.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize_or_zero",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::normalize_or_zero(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "powf",
-                |_self: Val<bevy::math::Vec4>, n: f32| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::powf(
-                            _self.into_inner(),
-                            n,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "project_onto",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::project_onto(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "project_onto_normalized",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::project_onto_normalized(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "recip",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::recip(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reflect",
-                |_self: Val<bevy::math::Vec4>, normal: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::reflect(
-                            _self.into_inner(),
-                            normal.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "refract",
-                |_self: Val<bevy::math::Vec4>, normal: Val<bevy::math::Vec4>, eta: f32| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::refract(
-                            _self.into_inner(),
-                            normal.into_inner(),
-                            eta,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reject_from",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::reject_from(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reject_from_normalized",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::reject_from_normalized(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::Vec4>, rhs: Ref<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Rem<
-                        &bevy::math::Vec4,
-                    >>::rem(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Rem<
-                        bevy::math::Vec4,
-                    >>::rem(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::Vec4>, rhs: f32| {
-                    let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Rem<
-                        f32,
-                    >>::rem(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem_euclid",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::rem_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "round",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::round(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "select",
-                |
-                    mask: Val<bevy::math::BVec4A>,
-                    if_true: Val<bevy::math::Vec4>,
-                    if_false: Val<bevy::math::Vec4>|
-                {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::select(
-                            mask.into_inner(),
-                            if_true.into_inner(),
-                            if_false.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "signum",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::signum(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: f32| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::Vec4>, rhs: Ref<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Sub<
-                        &bevy::math::Vec4,
-                    >>::sub(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::Vec4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Sub<
-                        bevy::math::Vec4,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::Vec4>, rhs: f32| {
-                    let output: Val<bevy::math::Vec4> = <bevy::math::Vec4 as std::ops::Sub<
-                        f32,
-                    >>::sub(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::Vec4>| {
-                    let output: [f32; 4] = bevy::math::Vec4::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "trunc",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::trunc(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "truncate",
-                |_self: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Vec4::truncate(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_w",
-                |_self: Val<bevy::math::Vec4>, w: f32| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::with_w(
-                            _self.into_inner(),
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_x",
-                |_self: Val<bevy::math::Vec4>, x: f32| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::with_x(
-                            _self.into_inner(),
-                            x,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_y",
-                |_self: Val<bevy::math::Vec4>, y: f32| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::with_y(
-                            _self.into_inner(),
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_z",
-                |_self: Val<bevy::math::Vec4>, z: f32| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Vec4::with_z(
-                            _self.into_inner(),
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::BVec2>::new(world)
-            .register(
-                "all",
-                |_self: Val<bevy::math::BVec2>| {
-                    let output: bool = bevy::math::BVec2::all(_self.into_inner()).into();
-                    output
-                },
-            )
-            .register(
-                "any",
-                |_self: Val<bevy::math::BVec2>| {
-                    let output: bool = bevy::math::BVec2::any(_self.into_inner()).into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::BVec2>| {
-                    let output: () = <bevy::math::BVec2 as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "bitmask",
-                |_self: Val<bevy::math::BVec2>| {
-                    let output: u32 = bevy::math::BVec2::bitmask(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::BVec2>| {
-                    let output: Val<bevy::math::BVec2> = <bevy::math::BVec2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::BVec2>, other: Ref<bevy::math::BVec2>| {
-                    let output: bool = <bevy::math::BVec2 as std::cmp::PartialEq<
-                        bevy::math::BVec2,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [bool; 2]| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::BVec2::from_array(a)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: bool, y: bool| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::BVec2::new(x, y)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "set",
-                |mut _self: Mut<bevy::math::BVec2>, index: usize, value: bool| {
-                    let output: () = bevy::math::BVec2::set(&mut _self, index, value)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: bool| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::BVec2::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "test",
-                |_self: Ref<bevy::math::BVec2>, index: usize| {
-                    let output: bool = bevy::math::BVec2::test(&_self, index).into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::BVec3>::new(world)
-            .register(
-                "all",
-                |_self: Val<bevy::math::BVec3>| {
-                    let output: bool = bevy::math::BVec3::all(_self.into_inner()).into();
-                    output
-                },
-            )
-            .register(
-                "any",
-                |_self: Val<bevy::math::BVec3>| {
-                    let output: bool = bevy::math::BVec3::any(_self.into_inner()).into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::BVec3>| {
-                    let output: () = <bevy::math::BVec3 as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "bitmask",
-                |_self: Val<bevy::math::BVec3>| {
-                    let output: u32 = bevy::math::BVec3::bitmask(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::BVec3>| {
-                    let output: Val<bevy::math::BVec3> = <bevy::math::BVec3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::BVec3>, other: Ref<bevy::math::BVec3>| {
-                    let output: bool = <bevy::math::BVec3 as std::cmp::PartialEq<
-                        bevy::math::BVec3,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [bool; 3]| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::BVec3::from_array(a)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: bool, y: bool, z: bool| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::BVec3::new(x, y, z)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "set",
-                |mut _self: Mut<bevy::math::BVec3>, index: usize, value: bool| {
-                    let output: () = bevy::math::BVec3::set(&mut _self, index, value)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: bool| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::BVec3::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "test",
-                |_self: Ref<bevy::math::BVec3>, index: usize| {
-                    let output: bool = bevy::math::BVec3::test(&_self, index).into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::BVec4>::new(world)
-            .register(
-                "all",
-                |_self: Val<bevy::math::BVec4>| {
-                    let output: bool = bevy::math::BVec4::all(_self.into_inner()).into();
-                    output
-                },
-            )
-            .register(
-                "any",
-                |_self: Val<bevy::math::BVec4>| {
-                    let output: bool = bevy::math::BVec4::any(_self.into_inner()).into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::BVec4>| {
-                    let output: () = <bevy::math::BVec4 as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "bitmask",
-                |_self: Val<bevy::math::BVec4>| {
-                    let output: u32 = bevy::math::BVec4::bitmask(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::BVec4>| {
-                    let output: Val<bevy::math::BVec4> = <bevy::math::BVec4 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::BVec4>, other: Ref<bevy::math::BVec4>| {
-                    let output: bool = <bevy::math::BVec4 as std::cmp::PartialEq<
-                        bevy::math::BVec4,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [bool; 4]| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::BVec4::from_array(a)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: bool, y: bool, z: bool, w: bool| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::BVec4::new(
-                            x,
-                            y,
-                            z,
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "set",
-                |mut _self: Mut<bevy::math::BVec4>, index: usize, value: bool| {
-                    let output: () = bevy::math::BVec4::set(&mut _self, index, value)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: bool| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::BVec4::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "test",
-                |_self: Ref<bevy::math::BVec4>, index: usize| {
-                    let output: bool = bevy::math::BVec4::test(&_self, index).into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::DVec2>::new(world)
-            .register(
-                "abs",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::abs(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Val<bevy::math::DVec2>,
-                    rhs: Val<bevy::math::DVec2>,
-                    max_abs_diff: f64|
-                {
-                    let output: bool = bevy::math::DVec2::abs_diff_eq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::DVec2>, rhs: Ref<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Add<
-                        &bevy::math::DVec2,
-                    >>::add(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Add<
-                        bevy::math::DVec2,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::DVec2>, rhs: f64| {
-                    let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Add<
-                        f64,
-                    >>::add(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "angle_between",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: f64 = bevy::math::DVec2::angle_between(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "angle_to",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: f64 = bevy::math::DVec2::angle_to(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_i64vec2",
-                |_self: Ref<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::I64Vec2> = bevy::math::DVec2::as_i64vec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_ivec2",
-                |_self: Ref<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::IVec2> = bevy::math::DVec2::as_ivec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_u64vec2",
-                |_self: Ref<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::U64Vec2> = bevy::math::DVec2::as_u64vec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_uvec2",
-                |_self: Ref<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::UVec2> = bevy::math::DVec2::as_uvec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec2",
-                |_self: Ref<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::DVec2::as_vec2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "ceil",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::ceil(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp",
-                |
-                    _self: Val<bevy::math::DVec2>,
-                    min: Val<bevy::math::DVec2>,
-                    max: Val<bevy::math::DVec2>|
-                {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::clamp(
-                            _self.into_inner(),
-                            min.into_inner(),
-                            max.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length",
-                |_self: Val<bevy::math::DVec2>, min: f64, max: f64| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::clamp_length(
-                            _self.into_inner(),
-                            min,
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length_max",
-                |_self: Val<bevy::math::DVec2>, max: f64| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::clamp_length_max(
-                            _self.into_inner(),
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length_min",
-                |_self: Val<bevy::math::DVec2>, min: f64| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::clamp_length_min(
-                            _self.into_inner(),
-                            min,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpeq",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::DVec2::cmpeq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpge",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::DVec2::cmpge(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpgt",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::DVec2::cmpgt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmple",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::DVec2::cmple(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmplt",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::DVec2::cmplt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpne",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::DVec2::cmpne(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "copysign",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::copysign(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: f64 = bevy::math::DVec2::distance(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance_squared",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: f64 = bevy::math::DVec2::distance_squared(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::DVec2>, rhs: Ref<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Div<
-                        &bevy::math::DVec2,
-                    >>::div(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Div<
-                        bevy::math::DVec2,
-                    >>::div(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::DVec2>, rhs: f64| {
-                    let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Div<
-                        f64,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_euclid",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::div_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: f64 = bevy::math::DVec2::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot_into_vec",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::dot_into_vec(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_product",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: f64 = bevy::math::DVec2::element_product(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_sum",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: f64 = bevy::math::DVec2::element_sum(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::DVec2>, other: Ref<bevy::math::DVec2>| {
-                    let output: bool = <bevy::math::DVec2 as std::cmp::PartialEq<
-                        bevy::math::DVec2,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "exp",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::exp(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "extend",
-                |_self: Val<bevy::math::DVec2>, z: f64| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec2::extend(
-                            _self.into_inner(),
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "floor",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::floor(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fract",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::fract(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fract_gl",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::fract_gl(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_angle",
-                |angle: f64| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::from_angle(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [f64; 2]| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::from_array(a)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: bool = bevy::math::DVec2::is_finite(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite_mask",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::DVec2::is_finite_mask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: bool = bevy::math::DVec2::is_nan(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_nan_mask",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::BVec2> = bevy::math::DVec2::is_nan_mask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_negative_bitmask",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: u32 = bevy::math::DVec2::is_negative_bitmask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_normalized",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: bool = bevy::math::DVec2::is_normalized(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: f64 = bevy::math::DVec2::length(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_recip",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: f64 = bevy::math::DVec2::length_recip(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: f64 = bevy::math::DVec2::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "lerp",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>, s: f64| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::lerp(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                            s,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::max(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max_element",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: f64 = bevy::math::DVec2::max_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "midpoint",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::midpoint(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::min(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min_element",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: f64 = bevy::math::DVec2::min_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "move_towards",
-                |_self: Ref<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>, d: f64| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::move_towards(
-                            &_self,
-                            rhs.into_inner(),
-                            d,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DVec2>, rhs: Ref<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Mul<
-                        &bevy::math::DVec2,
-                    >>::mul(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Mul<
-                        bevy::math::DVec2,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DVec2>, rhs: f64| {
-                    let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Mul<
-                        f64,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_add",
-                |
-                    _self: Val<bevy::math::DVec2>,
-                    a: Val<bevy::math::DVec2>,
-                    b: Val<bevy::math::DVec2>|
-                {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::mul_add(
-                            _self.into_inner(),
-                            a.into_inner(),
-                            b.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: f64, y: f64| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::new(x, y)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::normalize(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize_or",
-                |_self: Val<bevy::math::DVec2>, fallback: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::normalize_or(
-                            _self.into_inner(),
-                            fallback.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize_or_zero",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::normalize_or_zero(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perp",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::perp(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perp_dot",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: f64 = bevy::math::DVec2::perp_dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "powf",
-                |_self: Val<bevy::math::DVec2>, n: f64| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::powf(
-                            _self.into_inner(),
-                            n,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "project_onto",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::project_onto(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "project_onto_normalized",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::project_onto_normalized(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "recip",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::recip(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reflect",
-                |_self: Val<bevy::math::DVec2>, normal: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::reflect(
-                            _self.into_inner(),
-                            normal.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "refract",
-                |
-                    _self: Val<bevy::math::DVec2>,
-                    normal: Val<bevy::math::DVec2>,
-                    eta: f64|
-                {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::refract(
-                            _self.into_inner(),
-                            normal.into_inner(),
-                            eta,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reject_from",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::reject_from(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reject_from_normalized",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::reject_from_normalized(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::DVec2>, rhs: Ref<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Rem<
-                        &bevy::math::DVec2,
-                    >>::rem(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Rem<
-                        bevy::math::DVec2,
-                    >>::rem(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::DVec2>, rhs: f64| {
-                    let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Rem<
-                        f64,
-                    >>::rem(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem_euclid",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::rem_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotate",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::rotate(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotate_towards",
-                |
-                    _self: Ref<bevy::math::DVec2>,
-                    rhs: Val<bevy::math::DVec2>,
-                    max_angle: f64|
-                {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::rotate_towards(
-                            &_self,
-                            rhs.into_inner(),
-                            max_angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "round",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::round(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "select",
-                |
-                    mask: Val<bevy::math::BVec2>,
-                    if_true: Val<bevy::math::DVec2>,
-                    if_false: Val<bevy::math::DVec2>|
-                {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::select(
-                            mask.into_inner(),
-                            if_true.into_inner(),
-                            if_false.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "signum",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::signum(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: f64| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::DVec2>, rhs: Ref<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Sub<
-                        &bevy::math::DVec2,
-                    >>::sub(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::DVec2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Sub<
-                        bevy::math::DVec2,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::DVec2>, rhs: f64| {
-                    let output: Val<bevy::math::DVec2> = <bevy::math::DVec2 as std::ops::Sub<
-                        f64,
-                    >>::sub(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_angle",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: f64 = bevy::math::DVec2::to_angle(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::DVec2>| {
-                    let output: [f64; 2] = bevy::math::DVec2::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "trunc",
-                |_self: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::trunc(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_x",
-                |_self: Val<bevy::math::DVec2>, x: f64| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::with_x(
-                            _self.into_inner(),
-                            x,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_y",
-                |_self: Val<bevy::math::DVec2>, y: f64| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec2::with_y(
-                            _self.into_inner(),
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::DVec3>::new(world)
-            .register(
-                "abs",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::abs(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Val<bevy::math::DVec3>,
-                    rhs: Val<bevy::math::DVec3>,
-                    max_abs_diff: f64|
-                {
-                    let output: bool = bevy::math::DVec3::abs_diff_eq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::DVec3>, rhs: Ref<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Add<
-                        &bevy::math::DVec3,
-                    >>::add(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Add<
-                        bevy::math::DVec3,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::DVec3>, rhs: f64| {
-                    let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Add<
-                        f64,
-                    >>::add(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "angle_between",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: f64 = bevy::math::DVec3::angle_between(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "any_orthogonal_vector",
-                |_self: Ref<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::any_orthogonal_vector(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "any_orthonormal_vector",
-                |_self: Ref<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::any_orthonormal_vector(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_i64vec3",
-                |_self: Ref<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::I64Vec3> = bevy::math::DVec3::as_i64vec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_ivec3",
-                |_self: Ref<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::IVec3> = bevy::math::DVec3::as_ivec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_u64vec3",
-                |_self: Ref<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::U64Vec3> = bevy::math::DVec3::as_u64vec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_uvec3",
-                |_self: Ref<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::UVec3> = bevy::math::DVec3::as_uvec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec3",
-                |_self: Ref<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::DVec3::as_vec3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec3a",
-                |_self: Ref<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::DVec3::as_vec3a(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "ceil",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::ceil(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp",
-                |
-                    _self: Val<bevy::math::DVec3>,
-                    min: Val<bevy::math::DVec3>,
-                    max: Val<bevy::math::DVec3>|
-                {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::clamp(
-                            _self.into_inner(),
-                            min.into_inner(),
-                            max.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length",
-                |_self: Val<bevy::math::DVec3>, min: f64, max: f64| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::clamp_length(
-                            _self.into_inner(),
-                            min,
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length_max",
-                |_self: Val<bevy::math::DVec3>, max: f64| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::clamp_length_max(
-                            _self.into_inner(),
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length_min",
-                |_self: Val<bevy::math::DVec3>, min: f64| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::clamp_length_min(
-                            _self.into_inner(),
-                            min,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpeq",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::DVec3::cmpeq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpge",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::DVec3::cmpge(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpgt",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::DVec3::cmpgt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmple",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::DVec3::cmple(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmplt",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::DVec3::cmplt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpne",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::DVec3::cmpne(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "copysign",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::copysign(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cross",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::cross(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: f64 = bevy::math::DVec3::distance(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance_squared",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: f64 = bevy::math::DVec3::distance_squared(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::DVec3>, rhs: Ref<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Div<
-                        &bevy::math::DVec3,
-                    >>::div(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Div<
-                        bevy::math::DVec3,
-                    >>::div(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::DVec3>, rhs: f64| {
-                    let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Div<
-                        f64,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_euclid",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::div_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: f64 = bevy::math::DVec3::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot_into_vec",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::dot_into_vec(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_product",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: f64 = bevy::math::DVec3::element_product(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_sum",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: f64 = bevy::math::DVec3::element_sum(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::DVec3>, other: Ref<bevy::math::DVec3>| {
-                    let output: bool = <bevy::math::DVec3 as std::cmp::PartialEq<
-                        bevy::math::DVec3,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "exp",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::exp(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "extend",
-                |_self: Val<bevy::math::DVec3>, w: f64| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec3::extend(
-                            _self.into_inner(),
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "floor",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::floor(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fract",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::fract(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fract_gl",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::fract_gl(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [f64; 3]| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::from_array(a)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: bool = bevy::math::DVec3::is_finite(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite_mask",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::DVec3::is_finite_mask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: bool = bevy::math::DVec3::is_nan(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_nan_mask",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::BVec3> = bevy::math::DVec3::is_nan_mask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_negative_bitmask",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: u32 = bevy::math::DVec3::is_negative_bitmask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_normalized",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: bool = bevy::math::DVec3::is_normalized(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: f64 = bevy::math::DVec3::length(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_recip",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: f64 = bevy::math::DVec3::length_recip(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: f64 = bevy::math::DVec3::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "lerp",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>, s: f64| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::lerp(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                            s,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::max(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max_element",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: f64 = bevy::math::DVec3::max_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "midpoint",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::midpoint(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::min(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min_element",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: f64 = bevy::math::DVec3::min_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "move_towards",
-                |_self: Ref<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>, d: f64| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::move_towards(
-                            &_self,
-                            rhs.into_inner(),
-                            d,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DVec3>, rhs: Ref<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Mul<
-                        &bevy::math::DVec3,
-                    >>::mul(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Mul<
-                        bevy::math::DVec3,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DVec3>, rhs: f64| {
-                    let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Mul<
-                        f64,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_add",
-                |
-                    _self: Val<bevy::math::DVec3>,
-                    a: Val<bevy::math::DVec3>,
-                    b: Val<bevy::math::DVec3>|
-                {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::mul_add(
-                            _self.into_inner(),
-                            a.into_inner(),
-                            b.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: f64, y: f64, z: f64| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::new(x, y, z)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::normalize(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize_or",
-                |_self: Val<bevy::math::DVec3>, fallback: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::normalize_or(
-                            _self.into_inner(),
-                            fallback.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize_or_zero",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::normalize_or_zero(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "powf",
-                |_self: Val<bevy::math::DVec3>, n: f64| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::powf(
-                            _self.into_inner(),
-                            n,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "project_onto",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::project_onto(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "project_onto_normalized",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::project_onto_normalized(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "recip",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::recip(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reflect",
-                |_self: Val<bevy::math::DVec3>, normal: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::reflect(
-                            _self.into_inner(),
-                            normal.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "refract",
-                |
-                    _self: Val<bevy::math::DVec3>,
-                    normal: Val<bevy::math::DVec3>,
-                    eta: f64|
-                {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::refract(
-                            _self.into_inner(),
-                            normal.into_inner(),
-                            eta,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reject_from",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::reject_from(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reject_from_normalized",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::reject_from_normalized(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::DVec3>, rhs: Ref<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Rem<
-                        &bevy::math::DVec3,
-                    >>::rem(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Rem<
-                        bevy::math::DVec3,
-                    >>::rem(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::DVec3>, rhs: f64| {
-                    let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Rem<
-                        f64,
-                    >>::rem(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem_euclid",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::rem_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "round",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::round(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "select",
-                |
-                    mask: Val<bevy::math::BVec3>,
-                    if_true: Val<bevy::math::DVec3>,
-                    if_false: Val<bevy::math::DVec3>|
-                {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::select(
-                            mask.into_inner(),
-                            if_true.into_inner(),
-                            if_false.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "signum",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::signum(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: f64| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::DVec3>, rhs: Ref<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Sub<
-                        &bevy::math::DVec3,
-                    >>::sub(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::DVec3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Sub<
-                        bevy::math::DVec3,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::DVec3>, rhs: f64| {
-                    let output: Val<bevy::math::DVec3> = <bevy::math::DVec3 as std::ops::Sub<
-                        f64,
-                    >>::sub(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::DVec3>| {
-                    let output: [f64; 3] = bevy::math::DVec3::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "trunc",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::trunc(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "truncate",
-                |_self: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DVec3::truncate(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_x",
-                |_self: Val<bevy::math::DVec3>, x: f64| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::with_x(
-                            _self.into_inner(),
-                            x,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_y",
-                |_self: Val<bevy::math::DVec3>, y: f64| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::with_y(
-                            _self.into_inner(),
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_z",
-                |_self: Val<bevy::math::DVec3>, z: f64| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec3::with_z(
-                            _self.into_inner(),
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::DVec4>::new(world)
-            .register(
-                "abs",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::abs(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Val<bevy::math::DVec4>,
-                    rhs: Val<bevy::math::DVec4>,
-                    max_abs_diff: f64|
-                {
-                    let output: bool = bevy::math::DVec4::abs_diff_eq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::DVec4>, rhs: Ref<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Add<
-                        &bevy::math::DVec4,
-                    >>::add(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Add<
-                        bevy::math::DVec4,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::DVec4>, rhs: f64| {
-                    let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Add<
-                        f64,
-                    >>::add(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_i64vec4",
-                |_self: Ref<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::I64Vec4> = bevy::math::DVec4::as_i64vec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_ivec4",
-                |_self: Ref<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::IVec4> = bevy::math::DVec4::as_ivec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_u64vec4",
-                |_self: Ref<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::U64Vec4> = bevy::math::DVec4::as_u64vec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_uvec4",
-                |_self: Ref<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::UVec4> = bevy::math::DVec4::as_uvec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_vec4",
-                |_self: Ref<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::DVec4::as_vec4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "ceil",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::ceil(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp",
-                |
-                    _self: Val<bevy::math::DVec4>,
-                    min: Val<bevy::math::DVec4>,
-                    max: Val<bevy::math::DVec4>|
-                {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::clamp(
-                            _self.into_inner(),
-                            min.into_inner(),
-                            max.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length",
-                |_self: Val<bevy::math::DVec4>, min: f64, max: f64| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::clamp_length(
-                            _self.into_inner(),
-                            min,
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length_max",
-                |_self: Val<bevy::math::DVec4>, max: f64| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::clamp_length_max(
-                            _self.into_inner(),
-                            max,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clamp_length_min",
-                |_self: Val<bevy::math::DVec4>, min: f64| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::clamp_length_min(
-                            _self.into_inner(),
-                            min,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpeq",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::DVec4::cmpeq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpge",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::DVec4::cmpge(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpgt",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::DVec4::cmpgt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmple",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::DVec4::cmple(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmplt",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::DVec4::cmplt(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "cmpne",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::DVec4::cmpne(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "copysign",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::copysign(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: f64 = bevy::math::DVec4::distance(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "distance_squared",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: f64 = bevy::math::DVec4::distance_squared(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::DVec4>, rhs: Ref<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Div<
-                        &bevy::math::DVec4,
-                    >>::div(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Div<
-                        bevy::math::DVec4,
-                    >>::div(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::DVec4>, rhs: f64| {
-                    let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Div<
-                        f64,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_euclid",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::div_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: f64 = bevy::math::DVec4::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot_into_vec",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::dot_into_vec(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_product",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: f64 = bevy::math::DVec4::element_product(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "element_sum",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: f64 = bevy::math::DVec4::element_sum(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::DVec4>, other: Ref<bevy::math::DVec4>| {
-                    let output: bool = <bevy::math::DVec4 as std::cmp::PartialEq<
-                        bevy::math::DVec4,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "exp",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::exp(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "floor",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::floor(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fract",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::fract(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fract_gl",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::fract_gl(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [f64; 4]| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::from_array(a)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: bool = bevy::math::DVec4::is_finite(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite_mask",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::DVec4::is_finite_mask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: bool = bevy::math::DVec4::is_nan(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_nan_mask",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::BVec4> = bevy::math::DVec4::is_nan_mask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_negative_bitmask",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: u32 = bevy::math::DVec4::is_negative_bitmask(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_normalized",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: bool = bevy::math::DVec4::is_normalized(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: f64 = bevy::math::DVec4::length(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_recip",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: f64 = bevy::math::DVec4::length_recip(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: f64 = bevy::math::DVec4::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "lerp",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>, s: f64| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::lerp(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                            s,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::max(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "max_element",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: f64 = bevy::math::DVec4::max_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "midpoint",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::midpoint(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::min(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "min_element",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: f64 = bevy::math::DVec4::min_element(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "move_towards",
-                |_self: Ref<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>, d: f64| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::move_towards(
-                            &_self,
-                            rhs.into_inner(),
-                            d,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DVec4>, rhs: Ref<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Mul<
-                        &bevy::math::DVec4,
-                    >>::mul(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Mul<
-                        bevy::math::DVec4,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DVec4>, rhs: f64| {
-                    let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Mul<
-                        f64,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_add",
-                |
-                    _self: Val<bevy::math::DVec4>,
-                    a: Val<bevy::math::DVec4>,
-                    b: Val<bevy::math::DVec4>|
-                {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::mul_add(
-                            _self.into_inner(),
-                            a.into_inner(),
-                            b.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: f64, y: f64, z: f64, w: f64| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::new(
-                            x,
-                            y,
-                            z,
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::normalize(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize_or",
-                |_self: Val<bevy::math::DVec4>, fallback: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::normalize_or(
-                            _self.into_inner(),
-                            fallback.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize_or_zero",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::normalize_or_zero(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "powf",
-                |_self: Val<bevy::math::DVec4>, n: f64| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::powf(
-                            _self.into_inner(),
-                            n,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "project_onto",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::project_onto(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "project_onto_normalized",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::project_onto_normalized(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "recip",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::recip(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reflect",
-                |_self: Val<bevy::math::DVec4>, normal: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::reflect(
-                            _self.into_inner(),
-                            normal.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "refract",
-                |
-                    _self: Val<bevy::math::DVec4>,
-                    normal: Val<bevy::math::DVec4>,
-                    eta: f64|
-                {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::refract(
-                            _self.into_inner(),
-                            normal.into_inner(),
-                            eta,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reject_from",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::reject_from(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reject_from_normalized",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::reject_from_normalized(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::DVec4>, rhs: Ref<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Rem<
-                        &bevy::math::DVec4,
-                    >>::rem(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Rem<
-                        bevy::math::DVec4,
-                    >>::rem(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem",
-                |_self: Val<bevy::math::DVec4>, rhs: f64| {
-                    let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Rem<
-                        f64,
-                    >>::rem(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rem_euclid",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::rem_euclid(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "round",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::round(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "select",
-                |
-                    mask: Val<bevy::math::BVec4>,
-                    if_true: Val<bevy::math::DVec4>,
-                    if_false: Val<bevy::math::DVec4>|
-                {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::select(
-                            mask.into_inner(),
-                            if_true.into_inner(),
-                            if_false.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "signum",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::signum(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: f64| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::DVec4>, rhs: Ref<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Sub<
-                        &bevy::math::DVec4,
-                    >>::sub(_self.into_inner(), &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::DVec4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Sub<
-                        bevy::math::DVec4,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::DVec4>, rhs: f64| {
-                    let output: Val<bevy::math::DVec4> = <bevy::math::DVec4 as std::ops::Sub<
-                        f64,
-                    >>::sub(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::DVec4>| {
-                    let output: [f64; 4] = bevy::math::DVec4::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "trunc",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::trunc(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "truncate",
-                |_self: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DVec4::truncate(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_w",
-                |_self: Val<bevy::math::DVec4>, w: f64| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::with_w(
-                            _self.into_inner(),
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_x",
-                |_self: Val<bevy::math::DVec4>, x: f64| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::with_x(
-                            _self.into_inner(),
-                            x,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_y",
-                |_self: Val<bevy::math::DVec4>, y: f64| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::with_y(
-                            _self.into_inner(),
-                            y,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_z",
-                |_self: Val<bevy::math::DVec4>, z: f64| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DVec4::with_z(
-                            _self.into_inner(),
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::Mat2>::new(world)
-            .register(
-                "abs",
-                |_self: Ref<bevy::math::Mat2>| {
-                    let output: Val<bevy::math::Mat2> = bevy::math::Mat2::abs(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Ref<bevy::math::Mat2>,
-                    rhs: Val<bevy::math::Mat2>,
-                    max_abs_diff: f32|
-                {
-                    let output: bool = bevy::math::Mat2::abs_diff_eq(
-                            &_self,
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::Mat2>, rhs: Val<bevy::math::Mat2>| {
-                    let output: Val<bevy::math::Mat2> = <bevy::math::Mat2 as std::ops::Add<
-                        bevy::math::Mat2,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add_mat2",
-                |_self: Ref<bevy::math::Mat2>, rhs: Ref<bevy::math::Mat2>| {
-                    let output: Val<bevy::math::Mat2> = bevy::math::Mat2::add_mat2(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dmat2",
-                |_self: Ref<bevy::math::Mat2>| {
-                    let output: Val<bevy::math::DMat2> = bevy::math::Mat2::as_dmat2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::Mat2>| {
-                    let output: Val<bevy::math::Mat2> = <bevy::math::Mat2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "col",
-                |_self: Ref<bevy::math::Mat2>, index: usize| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Mat2::col(
-                            &_self,
-                            index,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "determinant",
-                |_self: Ref<bevy::math::Mat2>| {
-                    let output: f32 = bevy::math::Mat2::determinant(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::Mat2>, rhs: f32| {
-                    let output: Val<bevy::math::Mat2> = <bevy::math::Mat2 as std::ops::Div<
-                        f32,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_scalar",
-                |_self: Ref<bevy::math::Mat2>, rhs: f32| {
-                    let output: Val<bevy::math::Mat2> = bevy::math::Mat2::div_scalar(
-                            &_self,
-                            rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::Mat2>, rhs: Ref<bevy::math::Mat2>| {
-                    let output: bool = <bevy::math::Mat2 as std::cmp::PartialEq<
-                        bevy::math::Mat2,
-                    >>::eq(&_self, &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_angle",
-                |angle: f32| {
-                    let output: Val<bevy::math::Mat2> = bevy::math::Mat2::from_angle(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_cols",
-                |x_axis: Val<bevy::math::Vec2>, y_axis: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Mat2> = bevy::math::Mat2::from_cols(
-                            x_axis.into_inner(),
-                            y_axis.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_diagonal",
-                |diagonal: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Mat2> = bevy::math::Mat2::from_diagonal(
-                            diagonal.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat3",
-                |m: Val<bevy::math::Mat3>| {
-                    let output: Val<bevy::math::Mat2> = bevy::math::Mat2::from_mat3(
-                            m.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat3_minor",
-                |m: Val<bevy::math::Mat3>, i: usize, j: usize| {
-                    let output: Val<bevy::math::Mat2> = bevy::math::Mat2::from_mat3_minor(
-                            m.into_inner(),
-                            i,
-                            j,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat3a",
-                |m: Val<bevy::math::Mat3A>| {
-                    let output: Val<bevy::math::Mat2> = bevy::math::Mat2::from_mat3a(
-                            m.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat3a_minor",
-                |m: Val<bevy::math::Mat3A>, i: usize, j: usize| {
-                    let output: Val<bevy::math::Mat2> = bevy::math::Mat2::from_mat3a_minor(
-                            m.into_inner(),
-                            i,
-                            j,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale_angle",
-                |scale: Val<bevy::math::Vec2>, angle: f32| {
-                    let output: Val<bevy::math::Mat2> = bevy::math::Mat2::from_scale_angle(
-                            scale.into_inner(),
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse",
-                |_self: Ref<bevy::math::Mat2>| {
-                    let output: Val<bevy::math::Mat2> = bevy::math::Mat2::inverse(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Ref<bevy::math::Mat2>| {
-                    let output: bool = bevy::math::Mat2::is_finite(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Ref<bevy::math::Mat2>| {
-                    let output: bool = bevy::math::Mat2::is_nan(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Mat2>, rhs: Val<bevy::math::Mat2>| {
-                    let output: Val<bevy::math::Mat2> = <bevy::math::Mat2 as std::ops::Mul<
-                        bevy::math::Mat2,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Mat2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = <bevy::math::Mat2 as std::ops::Mul<
-                        bevy::math::Vec2,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Mat2>, rhs: f32| {
-                    let output: Val<bevy::math::Mat2> = <bevy::math::Mat2 as std::ops::Mul<
-                        f32,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_mat2",
-                |_self: Ref<bevy::math::Mat2>, rhs: Ref<bevy::math::Mat2>| {
-                    let output: Val<bevy::math::Mat2> = bevy::math::Mat2::mul_mat2(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_scalar",
-                |_self: Ref<bevy::math::Mat2>, rhs: f32| {
-                    let output: Val<bevy::math::Mat2> = bevy::math::Mat2::mul_scalar(
-                            &_self,
-                            rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_vec2",
-                |_self: Ref<bevy::math::Mat2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Mat2::mul_vec2(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::Mat2>| {
-                    let output: Val<bevy::math::Mat2> = <bevy::math::Mat2 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "row",
-                |_self: Ref<bevy::math::Mat2>, index: usize| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Mat2::row(
-                            &_self,
-                            index,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::Mat2>, rhs: Val<bevy::math::Mat2>| {
-                    let output: Val<bevy::math::Mat2> = <bevy::math::Mat2 as std::ops::Sub<
-                        bevy::math::Mat2,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub_mat2",
-                |_self: Ref<bevy::math::Mat2>, rhs: Ref<bevy::math::Mat2>| {
-                    let output: Val<bevy::math::Mat2> = bevy::math::Mat2::sub_mat2(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array",
-                |_self: Ref<bevy::math::Mat2>| {
-                    let output: [f32; 4] = bevy::math::Mat2::to_cols_array(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array_2d",
-                |_self: Ref<bevy::math::Mat2>| {
-                    let output: [[f32; 2]; 2] = bevy::math::Mat2::to_cols_array_2d(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transpose",
-                |_self: Ref<bevy::math::Mat2>| {
-                    let output: Val<bevy::math::Mat2> = bevy::math::Mat2::transpose(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::Mat3>::new(world)
-            .register(
-                "abs",
-                |_self: Ref<bevy::math::Mat3>| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::abs(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Ref<bevy::math::Mat3>,
-                    rhs: Val<bevy::math::Mat3>,
-                    max_abs_diff: f32|
-                {
-                    let output: bool = bevy::math::Mat3::abs_diff_eq(
-                            &_self,
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::Mat3>, rhs: Val<bevy::math::Mat3>| {
-                    let output: Val<bevy::math::Mat3> = <bevy::math::Mat3 as std::ops::Add<
-                        bevy::math::Mat3,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add_mat3",
-                |_self: Ref<bevy::math::Mat3>, rhs: Ref<bevy::math::Mat3>| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::add_mat3(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dmat3",
-                |_self: Ref<bevy::math::Mat3>| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::Mat3::as_dmat3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::Mat3>| {
-                    let output: Val<bevy::math::Mat3> = <bevy::math::Mat3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "col",
-                |_self: Ref<bevy::math::Mat3>, index: usize| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Mat3::col(
-                            &_self,
-                            index,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "determinant",
-                |_self: Ref<bevy::math::Mat3>| {
-                    let output: f32 = bevy::math::Mat3::determinant(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::Mat3>, rhs: f32| {
-                    let output: Val<bevy::math::Mat3> = <bevy::math::Mat3 as std::ops::Div<
-                        f32,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_scalar",
-                |_self: Ref<bevy::math::Mat3>, rhs: f32| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::div_scalar(
-                            &_self,
-                            rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::Mat3>, rhs: Ref<bevy::math::Mat3>| {
-                    let output: bool = <bevy::math::Mat3 as std::cmp::PartialEq<
-                        bevy::math::Mat3,
-                    >>::eq(&_self, &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_angle",
-                |angle: f32| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_angle(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_axis_angle",
-                |axis: Val<bevy::math::Vec3>, angle: f32| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_axis_angle(
-                            axis.into_inner(),
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_cols",
-                |
-                    x_axis: Val<bevy::math::Vec3>,
-                    y_axis: Val<bevy::math::Vec3>,
-                    z_axis: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_cols(
-                            x_axis.into_inner(),
-                            y_axis.into_inner(),
-                            z_axis.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_diagonal",
-                |diagonal: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_diagonal(
-                            diagonal.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_euler",
-                |order: Val<bevy::math::EulerRot>, a: f32, b: f32, c: f32| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_euler(
-                            order.into_inner(),
-                            a,
-                            b,
-                            c,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat2",
-                |m: Val<bevy::math::Mat2>| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_mat2(
-                            m.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat4",
-                |m: Val<bevy::math::Mat4>| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_mat4(
-                            m.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat4_minor",
-                |m: Val<bevy::math::Mat4>, i: usize, j: usize| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_mat4_minor(
-                            m.into_inner(),
-                            i,
-                            j,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_quat",
-                |rotation: Val<bevy::math::Quat>| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_quat(
-                            rotation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_x",
-                |angle: f32| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_rotation_x(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_y",
-                |angle: f32| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_rotation_y(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_z",
-                |angle: f32| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_rotation_z(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale",
-                |scale: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_scale(
-                            scale.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale_angle_translation",
-                |
-                    scale: Val<bevy::math::Vec2>,
-                    angle: f32,
-                    translation: Val<bevy::math::Vec2>|
-                {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_scale_angle_translation(
-                            scale.into_inner(),
-                            angle,
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_translation",
-                |translation: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::from_translation(
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse",
-                |_self: Ref<bevy::math::Mat3>| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::inverse(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Ref<bevy::math::Mat3>| {
-                    let output: bool = bevy::math::Mat3::is_finite(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Ref<bevy::math::Mat3>| {
-                    let output: bool = bevy::math::Mat3::is_nan(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Mat3>, rhs: Val<bevy::math::Affine2>| {
-                    let output: Val<bevy::math::Mat3> = <bevy::math::Mat3 as std::ops::Mul<
-                        bevy::math::Affine2,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Mat3>, rhs: Val<bevy::math::Mat3>| {
-                    let output: Val<bevy::math::Mat3> = <bevy::math::Mat3 as std::ops::Mul<
-                        bevy::math::Mat3,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Mat3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Mat3 as std::ops::Mul<
-                        bevy::math::Vec3,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Mat3>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Mat3 as std::ops::Mul<
-                        bevy::math::Vec3A,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Mat3>, rhs: f32| {
-                    let output: Val<bevy::math::Mat3> = <bevy::math::Mat3 as std::ops::Mul<
-                        f32,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_mat3",
-                |_self: Ref<bevy::math::Mat3>, rhs: Ref<bevy::math::Mat3>| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::mul_mat3(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_scalar",
-                |_self: Ref<bevy::math::Mat3>, rhs: f32| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::mul_scalar(
-                            &_self,
-                            rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_vec3",
-                |_self: Ref<bevy::math::Mat3>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Mat3::mul_vec3(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_vec3a",
-                |_self: Ref<bevy::math::Mat3>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Mat3::mul_vec3a(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::Mat3>| {
-                    let output: Val<bevy::math::Mat3> = <bevy::math::Mat3 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "row",
-                |_self: Ref<bevy::math::Mat3>, index: usize| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Mat3::row(
-                            &_self,
-                            index,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::Mat3>, rhs: Val<bevy::math::Mat3>| {
-                    let output: Val<bevy::math::Mat3> = <bevy::math::Mat3 as std::ops::Sub<
-                        bevy::math::Mat3,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub_mat3",
-                |_self: Ref<bevy::math::Mat3>, rhs: Ref<bevy::math::Mat3>| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::sub_mat3(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array",
-                |_self: Ref<bevy::math::Mat3>| {
-                    let output: [f32; 9] = bevy::math::Mat3::to_cols_array(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array_2d",
-                |_self: Ref<bevy::math::Mat3>| {
-                    let output: [[f32; 3]; 3] = bevy::math::Mat3::to_cols_array_2d(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_euler",
-                |_self: Ref<bevy::math::Mat3>, order: Val<bevy::math::EulerRot>| {
-                    let output: (f32, f32, f32) = bevy::math::Mat3::to_euler(
-                            &_self,
-                            order.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_point2",
-                |_self: Ref<bevy::math::Mat3>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Mat3::transform_point2(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_vector2",
-                |_self: Ref<bevy::math::Mat3>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Mat3::transform_vector2(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transpose",
-                |_self: Ref<bevy::math::Mat3>| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::Mat3::transpose(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::Mat3A>::new(world)
-            .register(
-                "abs",
-                |_self: Ref<bevy::math::Mat3A>| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::abs(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Ref<bevy::math::Mat3A>,
-                    rhs: Val<bevy::math::Mat3A>,
-                    max_abs_diff: f32|
-                {
-                    let output: bool = bevy::math::Mat3A::abs_diff_eq(
-                            &_self,
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::Mat3A>, rhs: Val<bevy::math::Mat3A>| {
-                    let output: Val<bevy::math::Mat3A> = <bevy::math::Mat3A as std::ops::Add<
-                        bevy::math::Mat3A,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add_mat3",
-                |_self: Ref<bevy::math::Mat3A>, rhs: Ref<bevy::math::Mat3A>| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::add_mat3(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dmat3",
-                |_self: Ref<bevy::math::Mat3A>| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::Mat3A::as_dmat3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::Mat3A>| {
-                    let output: Val<bevy::math::Mat3A> = <bevy::math::Mat3A as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "col",
-                |_self: Ref<bevy::math::Mat3A>, index: usize| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Mat3A::col(
-                            &_self,
-                            index,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "determinant",
-                |_self: Ref<bevy::math::Mat3A>| {
-                    let output: f32 = bevy::math::Mat3A::determinant(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::Mat3A>, rhs: f32| {
-                    let output: Val<bevy::math::Mat3A> = <bevy::math::Mat3A as std::ops::Div<
-                        f32,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_scalar",
-                |_self: Ref<bevy::math::Mat3A>, rhs: f32| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::div_scalar(
-                            &_self,
-                            rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::Mat3A>, rhs: Ref<bevy::math::Mat3A>| {
-                    let output: bool = <bevy::math::Mat3A as std::cmp::PartialEq<
-                        bevy::math::Mat3A,
-                    >>::eq(&_self, &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_angle",
-                |angle: f32| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_angle(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_axis_angle",
-                |axis: Val<bevy::math::Vec3>, angle: f32| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_axis_angle(
-                            axis.into_inner(),
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_cols",
-                |
-                    x_axis: Val<bevy::math::Vec3A>,
-                    y_axis: Val<bevy::math::Vec3A>,
-                    z_axis: Val<bevy::math::Vec3A>|
-                {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_cols(
-                            x_axis.into_inner(),
-                            y_axis.into_inner(),
-                            z_axis.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_diagonal",
-                |diagonal: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_diagonal(
-                            diagonal.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_euler",
-                |order: Val<bevy::math::EulerRot>, a: f32, b: f32, c: f32| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_euler(
-                            order.into_inner(),
-                            a,
-                            b,
-                            c,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat2",
-                |m: Val<bevy::math::Mat2>| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_mat2(
-                            m.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat4",
-                |m: Val<bevy::math::Mat4>| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_mat4(
-                            m.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat4_minor",
-                |m: Val<bevy::math::Mat4>, i: usize, j: usize| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_mat4_minor(
-                            m.into_inner(),
-                            i,
-                            j,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_quat",
-                |rotation: Val<bevy::math::Quat>| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_quat(
-                            rotation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_x",
-                |angle: f32| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_rotation_x(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_y",
-                |angle: f32| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_rotation_y(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_z",
-                |angle: f32| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_rotation_z(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale",
-                |scale: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_scale(
-                            scale.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale_angle_translation",
-                |
-                    scale: Val<bevy::math::Vec2>,
-                    angle: f32,
-                    translation: Val<bevy::math::Vec2>|
-                {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_scale_angle_translation(
-                            scale.into_inner(),
-                            angle,
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_translation",
-                |translation: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::from_translation(
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse",
-                |_self: Ref<bevy::math::Mat3A>| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::inverse(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Ref<bevy::math::Mat3A>| {
-                    let output: bool = bevy::math::Mat3A::is_finite(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Ref<bevy::math::Mat3A>| {
-                    let output: bool = bevy::math::Mat3A::is_nan(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Mat3A>, rhs: Val<bevy::math::Affine2>| {
-                    let output: Val<bevy::math::Mat3A> = <bevy::math::Mat3A as std::ops::Mul<
-                        bevy::math::Affine2,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Mat3A>, rhs: Val<bevy::math::Mat3A>| {
-                    let output: Val<bevy::math::Mat3A> = <bevy::math::Mat3A as std::ops::Mul<
-                        bevy::math::Mat3A,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Mat3A>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = <bevy::math::Mat3A as std::ops::Mul<
-                        bevy::math::Vec3,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Mat3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = <bevy::math::Mat3A as std::ops::Mul<
-                        bevy::math::Vec3A,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Mat3A>, rhs: f32| {
-                    let output: Val<bevy::math::Mat3A> = <bevy::math::Mat3A as std::ops::Mul<
-                        f32,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_mat3",
-                |_self: Ref<bevy::math::Mat3A>, rhs: Ref<bevy::math::Mat3A>| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::mul_mat3(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_scalar",
-                |_self: Ref<bevy::math::Mat3A>, rhs: f32| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::mul_scalar(
-                            &_self,
-                            rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_vec3",
-                |_self: Ref<bevy::math::Mat3A>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Mat3A::mul_vec3(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_vec3a",
-                |_self: Ref<bevy::math::Mat3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Mat3A::mul_vec3a(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::Mat3A>| {
-                    let output: Val<bevy::math::Mat3A> = <bevy::math::Mat3A as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "row",
-                |_self: Ref<bevy::math::Mat3A>, index: usize| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Mat3A::row(
-                            &_self,
-                            index,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::Mat3A>, rhs: Val<bevy::math::Mat3A>| {
-                    let output: Val<bevy::math::Mat3A> = <bevy::math::Mat3A as std::ops::Sub<
-                        bevy::math::Mat3A,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub_mat3",
-                |_self: Ref<bevy::math::Mat3A>, rhs: Ref<bevy::math::Mat3A>| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::sub_mat3(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array",
-                |_self: Ref<bevy::math::Mat3A>| {
-                    let output: [f32; 9] = bevy::math::Mat3A::to_cols_array(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array_2d",
-                |_self: Ref<bevy::math::Mat3A>| {
-                    let output: [[f32; 3]; 3] = bevy::math::Mat3A::to_cols_array_2d(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_euler",
-                |_self: Ref<bevy::math::Mat3A>, order: Val<bevy::math::EulerRot>| {
-                    let output: (f32, f32, f32) = bevy::math::Mat3A::to_euler(
-                            &_self,
-                            order.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_point2",
-                |_self: Ref<bevy::math::Mat3A>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Mat3A::transform_point2(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_vector2",
-                |_self: Ref<bevy::math::Mat3A>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Mat3A::transform_vector2(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transpose",
-                |_self: Ref<bevy::math::Mat3A>| {
-                    let output: Val<bevy::math::Mat3A> = bevy::math::Mat3A::transpose(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::Mat4>::new(world)
-            .register(
-                "abs",
-                |_self: Ref<bevy::math::Mat4>| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::abs(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Ref<bevy::math::Mat4>,
-                    rhs: Val<bevy::math::Mat4>,
-                    max_abs_diff: f32|
-                {
-                    let output: bool = bevy::math::Mat4::abs_diff_eq(
-                            &_self,
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::Mat4>, rhs: Val<bevy::math::Mat4>| {
-                    let output: Val<bevy::math::Mat4> = <bevy::math::Mat4 as std::ops::Add<
-                        bevy::math::Mat4,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add_mat4",
-                |_self: Ref<bevy::math::Mat4>, rhs: Ref<bevy::math::Mat4>| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::add_mat4(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_dmat4",
-                |_self: Ref<bevy::math::Mat4>| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::Mat4::as_dmat4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::Mat4>| {
-                    let output: Val<bevy::math::Mat4> = <bevy::math::Mat4 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "col",
-                |_self: Ref<bevy::math::Mat4>, index: usize| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Mat4::col(
-                            &_self,
-                            index,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "determinant",
-                |_self: Ref<bevy::math::Mat4>| {
-                    let output: f32 = bevy::math::Mat4::determinant(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::Mat4>, rhs: f32| {
-                    let output: Val<bevy::math::Mat4> = <bevy::math::Mat4 as std::ops::Div<
-                        f32,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_scalar",
-                |_self: Ref<bevy::math::Mat4>, rhs: f32| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::div_scalar(
-                            &_self,
-                            rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::Mat4>, rhs: Ref<bevy::math::Mat4>| {
-                    let output: bool = <bevy::math::Mat4 as std::cmp::PartialEq<
-                        bevy::math::Mat4,
-                    >>::eq(&_self, &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_axis_angle",
-                |axis: Val<bevy::math::Vec3>, angle: f32| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_axis_angle(
-                            axis.into_inner(),
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_cols",
-                |
-                    x_axis: Val<bevy::math::Vec4>,
-                    y_axis: Val<bevy::math::Vec4>,
-                    z_axis: Val<bevy::math::Vec4>,
-                    w_axis: Val<bevy::math::Vec4>|
-                {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_cols(
-                            x_axis.into_inner(),
-                            y_axis.into_inner(),
-                            z_axis.into_inner(),
-                            w_axis.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_diagonal",
-                |diagonal: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_diagonal(
-                            diagonal.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_euler",
-                |order: Val<bevy::math::EulerRot>, a: f32, b: f32, c: f32| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_euler(
-                            order.into_inner(),
-                            a,
-                            b,
-                            c,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat3",
-                |m: Val<bevy::math::Mat3>| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_mat3(
-                            m.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat3a",
-                |m: Val<bevy::math::Mat3A>| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_mat3a(
-                            m.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_quat",
-                |rotation: Val<bevy::math::Quat>| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_quat(
-                            rotation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_translation",
-                |rotation: Val<bevy::math::Quat>, translation: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_rotation_translation(
-                            rotation.into_inner(),
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_x",
-                |angle: f32| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_rotation_x(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_y",
-                |angle: f32| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_rotation_y(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_z",
-                |angle: f32| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_rotation_z(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale",
-                |scale: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_scale(
-                            scale.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale_rotation_translation",
-                |
-                    scale: Val<bevy::math::Vec3>,
-                    rotation: Val<bevy::math::Quat>,
-                    translation: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_scale_rotation_translation(
-                            scale.into_inner(),
-                            rotation.into_inner(),
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_translation",
-                |translation: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::from_translation(
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse",
-                |_self: Ref<bevy::math::Mat4>| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::inverse(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Ref<bevy::math::Mat4>| {
-                    let output: bool = bevy::math::Mat4::is_finite(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Ref<bevy::math::Mat4>| {
-                    let output: bool = bevy::math::Mat4::is_nan(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "look_at_lh",
-                |
-                    eye: Val<bevy::math::Vec3>,
-                    center: Val<bevy::math::Vec3>,
-                    up: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::look_at_lh(
-                            eye.into_inner(),
-                            center.into_inner(),
-                            up.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "look_at_rh",
-                |
-                    eye: Val<bevy::math::Vec3>,
-                    center: Val<bevy::math::Vec3>,
-                    up: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::look_at_rh(
-                            eye.into_inner(),
-                            center.into_inner(),
-                            up.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "look_to_lh",
-                |
-                    eye: Val<bevy::math::Vec3>,
-                    dir: Val<bevy::math::Vec3>,
-                    up: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::look_to_lh(
-                            eye.into_inner(),
-                            dir.into_inner(),
-                            up.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "look_to_rh",
-                |
-                    eye: Val<bevy::math::Vec3>,
-                    dir: Val<bevy::math::Vec3>,
-                    up: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::look_to_rh(
-                            eye.into_inner(),
-                            dir.into_inner(),
-                            up.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Mat4>, rhs: Val<bevy::math::Affine3A>| {
-                    let output: Val<bevy::math::Mat4> = <bevy::math::Mat4 as std::ops::Mul<
-                        bevy::math::Affine3A,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Mat4>, rhs: Val<bevy::math::Mat4>| {
-                    let output: Val<bevy::math::Mat4> = <bevy::math::Mat4 as std::ops::Mul<
-                        bevy::math::Mat4,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Mat4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = <bevy::math::Mat4 as std::ops::Mul<
-                        bevy::math::Vec4,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Mat4>, rhs: f32| {
-                    let output: Val<bevy::math::Mat4> = <bevy::math::Mat4 as std::ops::Mul<
-                        f32,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_mat4",
-                |_self: Ref<bevy::math::Mat4>, rhs: Ref<bevy::math::Mat4>| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::mul_mat4(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_scalar",
-                |_self: Ref<bevy::math::Mat4>, rhs: f32| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::mul_scalar(
-                            &_self,
-                            rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_vec4",
-                |_self: Ref<bevy::math::Mat4>, rhs: Val<bevy::math::Vec4>| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Mat4::mul_vec4(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::Mat4>| {
-                    let output: Val<bevy::math::Mat4> = <bevy::math::Mat4 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "orthographic_lh",
-                |left: f32, right: f32, bottom: f32, top: f32, near: f32, far: f32| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::orthographic_lh(
-                            left,
-                            right,
-                            bottom,
-                            top,
-                            near,
-                            far,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "orthographic_rh",
-                |left: f32, right: f32, bottom: f32, top: f32, near: f32, far: f32| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::orthographic_rh(
-                            left,
-                            right,
-                            bottom,
-                            top,
-                            near,
-                            far,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "orthographic_rh_gl",
-                |left: f32, right: f32, bottom: f32, top: f32, near: f32, far: f32| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::orthographic_rh_gl(
-                            left,
-                            right,
-                            bottom,
-                            top,
-                            near,
-                            far,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perspective_infinite_lh",
-                |fov_y_radians: f32, aspect_ratio: f32, z_near: f32| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::perspective_infinite_lh(
-                            fov_y_radians,
-                            aspect_ratio,
-                            z_near,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perspective_infinite_reverse_lh",
-                |fov_y_radians: f32, aspect_ratio: f32, z_near: f32| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::perspective_infinite_reverse_lh(
-                            fov_y_radians,
-                            aspect_ratio,
-                            z_near,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perspective_infinite_reverse_rh",
-                |fov_y_radians: f32, aspect_ratio: f32, z_near: f32| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::perspective_infinite_reverse_rh(
-                            fov_y_radians,
-                            aspect_ratio,
-                            z_near,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perspective_infinite_rh",
-                |fov_y_radians: f32, aspect_ratio: f32, z_near: f32| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::perspective_infinite_rh(
-                            fov_y_radians,
-                            aspect_ratio,
-                            z_near,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perspective_lh",
-                |fov_y_radians: f32, aspect_ratio: f32, z_near: f32, z_far: f32| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::perspective_lh(
-                            fov_y_radians,
-                            aspect_ratio,
-                            z_near,
-                            z_far,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perspective_rh",
-                |fov_y_radians: f32, aspect_ratio: f32, z_near: f32, z_far: f32| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::perspective_rh(
-                            fov_y_radians,
-                            aspect_ratio,
-                            z_near,
-                            z_far,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perspective_rh_gl",
-                |fov_y_radians: f32, aspect_ratio: f32, z_near: f32, z_far: f32| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::perspective_rh_gl(
-                            fov_y_radians,
-                            aspect_ratio,
-                            z_near,
-                            z_far,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "project_point3",
-                |_self: Ref<bevy::math::Mat4>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Mat4::project_point3(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "project_point3a",
-                |_self: Ref<bevy::math::Mat4>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Mat4::project_point3a(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "row",
-                |_self: Ref<bevy::math::Mat4>, index: usize| {
-                    let output: Val<bevy::math::Vec4> = bevy::math::Mat4::row(
-                            &_self,
-                            index,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::Mat4>, rhs: Val<bevy::math::Mat4>| {
-                    let output: Val<bevy::math::Mat4> = <bevy::math::Mat4 as std::ops::Sub<
-                        bevy::math::Mat4,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub_mat4",
-                |_self: Ref<bevy::math::Mat4>, rhs: Ref<bevy::math::Mat4>| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::sub_mat4(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array",
-                |_self: Ref<bevy::math::Mat4>| {
-                    let output: [f32; 16] = bevy::math::Mat4::to_cols_array(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array_2d",
-                |_self: Ref<bevy::math::Mat4>| {
-                    let output: [[f32; 4]; 4] = bevy::math::Mat4::to_cols_array_2d(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_euler",
-                |_self: Ref<bevy::math::Mat4>, order: Val<bevy::math::EulerRot>| {
-                    let output: (f32, f32, f32) = bevy::math::Mat4::to_euler(
-                            &_self,
-                            order.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_point3",
-                |_self: Ref<bevy::math::Mat4>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Mat4::transform_point3(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_point3a",
-                |_self: Ref<bevy::math::Mat4>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Mat4::transform_point3a(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_vector3",
-                |_self: Ref<bevy::math::Mat4>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Mat4::transform_vector3(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_vector3a",
-                |_self: Ref<bevy::math::Mat4>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Mat4::transform_vector3a(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transpose",
-                |_self: Ref<bevy::math::Mat4>| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::Mat4::transpose(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::DMat2>::new(world)
-            .register(
-                "abs",
-                |_self: Ref<bevy::math::DMat2>| {
-                    let output: Val<bevy::math::DMat2> = bevy::math::DMat2::abs(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Ref<bevy::math::DMat2>,
-                    rhs: Val<bevy::math::DMat2>,
-                    max_abs_diff: f64|
-                {
-                    let output: bool = bevy::math::DMat2::abs_diff_eq(
-                            &_self,
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::DMat2>, rhs: Val<bevy::math::DMat2>| {
-                    let output: Val<bevy::math::DMat2> = <bevy::math::DMat2 as std::ops::Add<
-                        bevy::math::DMat2,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add_mat2",
-                |_self: Ref<bevy::math::DMat2>, rhs: Ref<bevy::math::DMat2>| {
-                    let output: Val<bevy::math::DMat2> = bevy::math::DMat2::add_mat2(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_mat2",
-                |_self: Ref<bevy::math::DMat2>| {
-                    let output: Val<bevy::math::Mat2> = bevy::math::DMat2::as_mat2(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::DMat2>| {
-                    let output: Val<bevy::math::DMat2> = <bevy::math::DMat2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "col",
-                |_self: Ref<bevy::math::DMat2>, index: usize| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DMat2::col(
-                            &_self,
-                            index,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "determinant",
-                |_self: Ref<bevy::math::DMat2>| {
-                    let output: f64 = bevy::math::DMat2::determinant(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::DMat2>, rhs: f64| {
-                    let output: Val<bevy::math::DMat2> = <bevy::math::DMat2 as std::ops::Div<
-                        f64,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_scalar",
-                |_self: Ref<bevy::math::DMat2>, rhs: f64| {
-                    let output: Val<bevy::math::DMat2> = bevy::math::DMat2::div_scalar(
-                            &_self,
-                            rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::DMat2>, rhs: Ref<bevy::math::DMat2>| {
-                    let output: bool = <bevy::math::DMat2 as std::cmp::PartialEq<
-                        bevy::math::DMat2,
-                    >>::eq(&_self, &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_angle",
-                |angle: f64| {
-                    let output: Val<bevy::math::DMat2> = bevy::math::DMat2::from_angle(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_cols",
-                |x_axis: Val<bevy::math::DVec2>, y_axis: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DMat2> = bevy::math::DMat2::from_cols(
-                            x_axis.into_inner(),
-                            y_axis.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_diagonal",
-                |diagonal: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DMat2> = bevy::math::DMat2::from_diagonal(
-                            diagonal.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat3",
-                |m: Val<bevy::math::DMat3>| {
-                    let output: Val<bevy::math::DMat2> = bevy::math::DMat2::from_mat3(
-                            m.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat3_minor",
-                |m: Val<bevy::math::DMat3>, i: usize, j: usize| {
-                    let output: Val<bevy::math::DMat2> = bevy::math::DMat2::from_mat3_minor(
-                            m.into_inner(),
-                            i,
-                            j,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale_angle",
-                |scale: Val<bevy::math::DVec2>, angle: f64| {
-                    let output: Val<bevy::math::DMat2> = bevy::math::DMat2::from_scale_angle(
-                            scale.into_inner(),
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse",
-                |_self: Ref<bevy::math::DMat2>| {
-                    let output: Val<bevy::math::DMat2> = bevy::math::DMat2::inverse(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Ref<bevy::math::DMat2>| {
-                    let output: bool = bevy::math::DMat2::is_finite(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Ref<bevy::math::DMat2>| {
-                    let output: bool = bevy::math::DMat2::is_nan(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DMat2>, rhs: Val<bevy::math::DMat2>| {
-                    let output: Val<bevy::math::DMat2> = <bevy::math::DMat2 as std::ops::Mul<
-                        bevy::math::DMat2,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DMat2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = <bevy::math::DMat2 as std::ops::Mul<
-                        bevy::math::DVec2,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DMat2>, rhs: f64| {
-                    let output: Val<bevy::math::DMat2> = <bevy::math::DMat2 as std::ops::Mul<
-                        f64,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_mat2",
-                |_self: Ref<bevy::math::DMat2>, rhs: Ref<bevy::math::DMat2>| {
-                    let output: Val<bevy::math::DMat2> = bevy::math::DMat2::mul_mat2(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_scalar",
-                |_self: Ref<bevy::math::DMat2>, rhs: f64| {
-                    let output: Val<bevy::math::DMat2> = bevy::math::DMat2::mul_scalar(
-                            &_self,
-                            rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_vec2",
-                |_self: Ref<bevy::math::DMat2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DMat2::mul_vec2(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::DMat2>| {
-                    let output: Val<bevy::math::DMat2> = <bevy::math::DMat2 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "row",
-                |_self: Ref<bevy::math::DMat2>, index: usize| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DMat2::row(
-                            &_self,
-                            index,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::DMat2>, rhs: Val<bevy::math::DMat2>| {
-                    let output: Val<bevy::math::DMat2> = <bevy::math::DMat2 as std::ops::Sub<
-                        bevy::math::DMat2,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub_mat2",
-                |_self: Ref<bevy::math::DMat2>, rhs: Ref<bevy::math::DMat2>| {
-                    let output: Val<bevy::math::DMat2> = bevy::math::DMat2::sub_mat2(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array",
-                |_self: Ref<bevy::math::DMat2>| {
-                    let output: [f64; 4] = bevy::math::DMat2::to_cols_array(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array_2d",
-                |_self: Ref<bevy::math::DMat2>| {
-                    let output: [[f64; 2]; 2] = bevy::math::DMat2::to_cols_array_2d(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transpose",
-                |_self: Ref<bevy::math::DMat2>| {
-                    let output: Val<bevy::math::DMat2> = bevy::math::DMat2::transpose(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::DMat3>::new(world)
-            .register(
-                "abs",
-                |_self: Ref<bevy::math::DMat3>| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::abs(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Ref<bevy::math::DMat3>,
-                    rhs: Val<bevy::math::DMat3>,
-                    max_abs_diff: f64|
-                {
-                    let output: bool = bevy::math::DMat3::abs_diff_eq(
-                            &_self,
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::DMat3>, rhs: Val<bevy::math::DMat3>| {
-                    let output: Val<bevy::math::DMat3> = <bevy::math::DMat3 as std::ops::Add<
-                        bevy::math::DMat3,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add_mat3",
-                |_self: Ref<bevy::math::DMat3>, rhs: Ref<bevy::math::DMat3>| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::add_mat3(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_mat3",
-                |_self: Ref<bevy::math::DMat3>| {
-                    let output: Val<bevy::math::Mat3> = bevy::math::DMat3::as_mat3(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::DMat3>| {
-                    let output: Val<bevy::math::DMat3> = <bevy::math::DMat3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "col",
-                |_self: Ref<bevy::math::DMat3>, index: usize| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DMat3::col(
-                            &_self,
-                            index,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "determinant",
-                |_self: Ref<bevy::math::DMat3>| {
-                    let output: f64 = bevy::math::DMat3::determinant(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::DMat3>, rhs: f64| {
-                    let output: Val<bevy::math::DMat3> = <bevy::math::DMat3 as std::ops::Div<
-                        f64,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_scalar",
-                |_self: Ref<bevy::math::DMat3>, rhs: f64| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::div_scalar(
-                            &_self,
-                            rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::DMat3>, rhs: Ref<bevy::math::DMat3>| {
-                    let output: bool = <bevy::math::DMat3 as std::cmp::PartialEq<
-                        bevy::math::DMat3,
-                    >>::eq(&_self, &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_angle",
-                |angle: f64| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_angle(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_axis_angle",
-                |axis: Val<bevy::math::DVec3>, angle: f64| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_axis_angle(
-                            axis.into_inner(),
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_cols",
-                |
-                    x_axis: Val<bevy::math::DVec3>,
-                    y_axis: Val<bevy::math::DVec3>,
-                    z_axis: Val<bevy::math::DVec3>|
-                {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_cols(
-                            x_axis.into_inner(),
-                            y_axis.into_inner(),
-                            z_axis.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_diagonal",
-                |diagonal: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_diagonal(
-                            diagonal.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_euler",
-                |order: Val<bevy::math::EulerRot>, a: f64, b: f64, c: f64| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_euler(
-                            order.into_inner(),
-                            a,
-                            b,
-                            c,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat2",
-                |m: Val<bevy::math::DMat2>| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_mat2(
-                            m.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat4",
-                |m: Val<bevy::math::DMat4>| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_mat4(
-                            m.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat4_minor",
-                |m: Val<bevy::math::DMat4>, i: usize, j: usize| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_mat4_minor(
-                            m.into_inner(),
-                            i,
-                            j,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_quat",
-                |rotation: Val<bevy::math::DQuat>| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_quat(
-                            rotation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_x",
-                |angle: f64| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_rotation_x(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_y",
-                |angle: f64| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_rotation_y(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_z",
-                |angle: f64| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_rotation_z(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale",
-                |scale: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_scale(
-                            scale.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale_angle_translation",
-                |
-                    scale: Val<bevy::math::DVec2>,
-                    angle: f64,
-                    translation: Val<bevy::math::DVec2>|
-                {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_scale_angle_translation(
-                            scale.into_inner(),
-                            angle,
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_translation",
-                |translation: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::from_translation(
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse",
-                |_self: Ref<bevy::math::DMat3>| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::inverse(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Ref<bevy::math::DMat3>| {
-                    let output: bool = bevy::math::DMat3::is_finite(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Ref<bevy::math::DMat3>| {
-                    let output: bool = bevy::math::DMat3::is_nan(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DMat3>, rhs: Val<bevy::math::DAffine2>| {
-                    let output: Val<bevy::math::DMat3> = <bevy::math::DMat3 as std::ops::Mul<
-                        bevy::math::DAffine2,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DMat3>, rhs: Val<bevy::math::DMat3>| {
-                    let output: Val<bevy::math::DMat3> = <bevy::math::DMat3 as std::ops::Mul<
-                        bevy::math::DMat3,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DMat3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = <bevy::math::DMat3 as std::ops::Mul<
-                        bevy::math::DVec3,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DMat3>, rhs: f64| {
-                    let output: Val<bevy::math::DMat3> = <bevy::math::DMat3 as std::ops::Mul<
-                        f64,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_mat3",
-                |_self: Ref<bevy::math::DMat3>, rhs: Ref<bevy::math::DMat3>| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::mul_mat3(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_scalar",
-                |_self: Ref<bevy::math::DMat3>, rhs: f64| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::mul_scalar(
-                            &_self,
-                            rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_vec3",
-                |_self: Ref<bevy::math::DMat3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DMat3::mul_vec3(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::DMat3>| {
-                    let output: Val<bevy::math::DMat3> = <bevy::math::DMat3 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "row",
-                |_self: Ref<bevy::math::DMat3>, index: usize| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DMat3::row(
-                            &_self,
-                            index,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::DMat3>, rhs: Val<bevy::math::DMat3>| {
-                    let output: Val<bevy::math::DMat3> = <bevy::math::DMat3 as std::ops::Sub<
-                        bevy::math::DMat3,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub_mat3",
-                |_self: Ref<bevy::math::DMat3>, rhs: Ref<bevy::math::DMat3>| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::sub_mat3(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array",
-                |_self: Ref<bevy::math::DMat3>| {
-                    let output: [f64; 9] = bevy::math::DMat3::to_cols_array(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array_2d",
-                |_self: Ref<bevy::math::DMat3>| {
-                    let output: [[f64; 3]; 3] = bevy::math::DMat3::to_cols_array_2d(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_euler",
-                |_self: Ref<bevy::math::DMat3>, order: Val<bevy::math::EulerRot>| {
-                    let output: (f64, f64, f64) = bevy::math::DMat3::to_euler(
-                            &_self,
-                            order.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_point2",
-                |_self: Ref<bevy::math::DMat3>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DMat3::transform_point2(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_vector2",
-                |_self: Ref<bevy::math::DMat3>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DMat3::transform_vector2(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transpose",
-                |_self: Ref<bevy::math::DMat3>| {
-                    let output: Val<bevy::math::DMat3> = bevy::math::DMat3::transpose(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::DMat4>::new(world)
-            .register(
-                "abs",
-                |_self: Ref<bevy::math::DMat4>| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::abs(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Ref<bevy::math::DMat4>,
-                    rhs: Val<bevy::math::DMat4>,
-                    max_abs_diff: f64|
-                {
-                    let output: bool = bevy::math::DMat4::abs_diff_eq(
-                            &_self,
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::DMat4>, rhs: Val<bevy::math::DMat4>| {
-                    let output: Val<bevy::math::DMat4> = <bevy::math::DMat4 as std::ops::Add<
-                        bevy::math::DMat4,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add_mat4",
-                |_self: Ref<bevy::math::DMat4>, rhs: Ref<bevy::math::DMat4>| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::add_mat4(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_mat4",
-                |_self: Ref<bevy::math::DMat4>| {
-                    let output: Val<bevy::math::Mat4> = bevy::math::DMat4::as_mat4(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::DMat4>| {
-                    let output: Val<bevy::math::DMat4> = <bevy::math::DMat4 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "col",
-                |_self: Ref<bevy::math::DMat4>, index: usize| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DMat4::col(
-                            &_self,
-                            index,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "determinant",
-                |_self: Ref<bevy::math::DMat4>| {
-                    let output: f64 = bevy::math::DMat4::determinant(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::DMat4>, rhs: f64| {
-                    let output: Val<bevy::math::DMat4> = <bevy::math::DMat4 as std::ops::Div<
-                        f64,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div_scalar",
-                |_self: Ref<bevy::math::DMat4>, rhs: f64| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::div_scalar(
-                            &_self,
-                            rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::DMat4>, rhs: Ref<bevy::math::DMat4>| {
-                    let output: bool = <bevy::math::DMat4 as std::cmp::PartialEq<
-                        bevy::math::DMat4,
-                    >>::eq(&_self, &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_axis_angle",
-                |axis: Val<bevy::math::DVec3>, angle: f64| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_axis_angle(
-                            axis.into_inner(),
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_cols",
-                |
-                    x_axis: Val<bevy::math::DVec4>,
-                    y_axis: Val<bevy::math::DVec4>,
-                    z_axis: Val<bevy::math::DVec4>,
-                    w_axis: Val<bevy::math::DVec4>|
-                {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_cols(
-                            x_axis.into_inner(),
-                            y_axis.into_inner(),
-                            z_axis.into_inner(),
-                            w_axis.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_diagonal",
-                |diagonal: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_diagonal(
-                            diagonal.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_euler",
-                |order: Val<bevy::math::EulerRot>, a: f64, b: f64, c: f64| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_euler(
-                            order.into_inner(),
-                            a,
-                            b,
-                            c,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat3",
-                |m: Val<bevy::math::DMat3>| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_mat3(
-                            m.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_quat",
-                |rotation: Val<bevy::math::DQuat>| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_quat(
-                            rotation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_translation",
-                |rotation: Val<bevy::math::DQuat>, translation: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_rotation_translation(
-                            rotation.into_inner(),
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_x",
-                |angle: f64| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_rotation_x(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_y",
-                |angle: f64| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_rotation_y(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_z",
-                |angle: f64| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_rotation_z(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale",
-                |scale: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_scale(
-                            scale.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale_rotation_translation",
-                |
-                    scale: Val<bevy::math::DVec3>,
-                    rotation: Val<bevy::math::DQuat>,
-                    translation: Val<bevy::math::DVec3>|
-                {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_scale_rotation_translation(
-                            scale.into_inner(),
-                            rotation.into_inner(),
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_translation",
-                |translation: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::from_translation(
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse",
-                |_self: Ref<bevy::math::DMat4>| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::inverse(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Ref<bevy::math::DMat4>| {
-                    let output: bool = bevy::math::DMat4::is_finite(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Ref<bevy::math::DMat4>| {
-                    let output: bool = bevy::math::DMat4::is_nan(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "look_at_lh",
-                |
-                    eye: Val<bevy::math::DVec3>,
-                    center: Val<bevy::math::DVec3>,
-                    up: Val<bevy::math::DVec3>|
-                {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::look_at_lh(
-                            eye.into_inner(),
-                            center.into_inner(),
-                            up.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "look_at_rh",
-                |
-                    eye: Val<bevy::math::DVec3>,
-                    center: Val<bevy::math::DVec3>,
-                    up: Val<bevy::math::DVec3>|
-                {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::look_at_rh(
-                            eye.into_inner(),
-                            center.into_inner(),
-                            up.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "look_to_lh",
-                |
-                    eye: Val<bevy::math::DVec3>,
-                    dir: Val<bevy::math::DVec3>,
-                    up: Val<bevy::math::DVec3>|
-                {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::look_to_lh(
-                            eye.into_inner(),
-                            dir.into_inner(),
-                            up.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "look_to_rh",
-                |
-                    eye: Val<bevy::math::DVec3>,
-                    dir: Val<bevy::math::DVec3>,
-                    up: Val<bevy::math::DVec3>|
-                {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::look_to_rh(
-                            eye.into_inner(),
-                            dir.into_inner(),
-                            up.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DMat4>, rhs: Val<bevy::math::DAffine3>| {
-                    let output: Val<bevy::math::DMat4> = <bevy::math::DMat4 as std::ops::Mul<
-                        bevy::math::DAffine3,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DMat4>, rhs: Val<bevy::math::DMat4>| {
-                    let output: Val<bevy::math::DMat4> = <bevy::math::DMat4 as std::ops::Mul<
-                        bevy::math::DMat4,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DMat4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = <bevy::math::DMat4 as std::ops::Mul<
-                        bevy::math::DVec4,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DMat4>, rhs: f64| {
-                    let output: Val<bevy::math::DMat4> = <bevy::math::DMat4 as std::ops::Mul<
-                        f64,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_mat4",
-                |_self: Ref<bevy::math::DMat4>, rhs: Ref<bevy::math::DMat4>| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::mul_mat4(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_scalar",
-                |_self: Ref<bevy::math::DMat4>, rhs: f64| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::mul_scalar(
-                            &_self,
-                            rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_vec4",
-                |_self: Ref<bevy::math::DMat4>, rhs: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DMat4::mul_vec4(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::DMat4>| {
-                    let output: Val<bevy::math::DMat4> = <bevy::math::DMat4 as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "orthographic_lh",
-                |left: f64, right: f64, bottom: f64, top: f64, near: f64, far: f64| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::orthographic_lh(
-                            left,
-                            right,
-                            bottom,
-                            top,
-                            near,
-                            far,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "orthographic_rh",
-                |left: f64, right: f64, bottom: f64, top: f64, near: f64, far: f64| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::orthographic_rh(
-                            left,
-                            right,
-                            bottom,
-                            top,
-                            near,
-                            far,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "orthographic_rh_gl",
-                |left: f64, right: f64, bottom: f64, top: f64, near: f64, far: f64| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::orthographic_rh_gl(
-                            left,
-                            right,
-                            bottom,
-                            top,
-                            near,
-                            far,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perspective_infinite_lh",
-                |fov_y_radians: f64, aspect_ratio: f64, z_near: f64| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::perspective_infinite_lh(
-                            fov_y_radians,
-                            aspect_ratio,
-                            z_near,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perspective_infinite_reverse_lh",
-                |fov_y_radians: f64, aspect_ratio: f64, z_near: f64| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::perspective_infinite_reverse_lh(
-                            fov_y_radians,
-                            aspect_ratio,
-                            z_near,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perspective_infinite_reverse_rh",
-                |fov_y_radians: f64, aspect_ratio: f64, z_near: f64| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::perspective_infinite_reverse_rh(
-                            fov_y_radians,
-                            aspect_ratio,
-                            z_near,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perspective_infinite_rh",
-                |fov_y_radians: f64, aspect_ratio: f64, z_near: f64| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::perspective_infinite_rh(
-                            fov_y_radians,
-                            aspect_ratio,
-                            z_near,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perspective_lh",
-                |fov_y_radians: f64, aspect_ratio: f64, z_near: f64, z_far: f64| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::perspective_lh(
-                            fov_y_radians,
-                            aspect_ratio,
-                            z_near,
-                            z_far,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perspective_rh",
-                |fov_y_radians: f64, aspect_ratio: f64, z_near: f64, z_far: f64| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::perspective_rh(
-                            fov_y_radians,
-                            aspect_ratio,
-                            z_near,
-                            z_far,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "perspective_rh_gl",
-                |fov_y_radians: f64, aspect_ratio: f64, z_near: f64, z_far: f64| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::perspective_rh_gl(
-                            fov_y_radians,
-                            aspect_ratio,
-                            z_near,
-                            z_far,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "project_point3",
-                |_self: Ref<bevy::math::DMat4>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DMat4::project_point3(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "row",
-                |_self: Ref<bevy::math::DMat4>, index: usize| {
-                    let output: Val<bevy::math::DVec4> = bevy::math::DMat4::row(
-                            &_self,
-                            index,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::DMat4>, rhs: Val<bevy::math::DMat4>| {
-                    let output: Val<bevy::math::DMat4> = <bevy::math::DMat4 as std::ops::Sub<
-                        bevy::math::DMat4,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub_mat4",
-                |_self: Ref<bevy::math::DMat4>, rhs: Ref<bevy::math::DMat4>| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::sub_mat4(
-                            &_self,
-                            &rhs,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array",
-                |_self: Ref<bevy::math::DMat4>| {
-                    let output: [f64; 16] = bevy::math::DMat4::to_cols_array(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array_2d",
-                |_self: Ref<bevy::math::DMat4>| {
-                    let output: [[f64; 4]; 4] = bevy::math::DMat4::to_cols_array_2d(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_euler",
-                |_self: Ref<bevy::math::DMat4>, order: Val<bevy::math::EulerRot>| {
-                    let output: (f64, f64, f64) = bevy::math::DMat4::to_euler(
-                            &_self,
-                            order.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_point3",
-                |_self: Ref<bevy::math::DMat4>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DMat4::transform_point3(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_vector3",
-                |_self: Ref<bevy::math::DMat4>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DMat4::transform_vector3(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transpose",
-                |_self: Ref<bevy::math::DMat4>| {
-                    let output: Val<bevy::math::DMat4> = bevy::math::DMat4::transpose(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::Affine2>::new(world)
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Ref<bevy::math::Affine2>,
-                    rhs: Val<bevy::math::Affine2>,
-                    max_abs_diff: f32|
-                {
-                    let output: bool = bevy::math::Affine2::abs_diff_eq(
-                            &_self,
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::Affine2>| {
-                    let output: Val<bevy::math::Affine2> = <bevy::math::Affine2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::Affine2>, rhs: Ref<bevy::math::Affine2>| {
-                    let output: bool = <bevy::math::Affine2 as std::cmp::PartialEq<
-                        bevy::math::Affine2,
-                    >>::eq(&_self, &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_angle",
-                |angle: f32| {
-                    let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_angle(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_angle_translation",
-                |angle: f32, translation: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_angle_translation(
-                            angle,
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_cols",
-                |
-                    x_axis: Val<bevy::math::Vec2>,
-                    y_axis: Val<bevy::math::Vec2>,
-                    z_axis: Val<bevy::math::Vec2>|
-                {
-                    let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_cols(
-                            x_axis.into_inner(),
-                            y_axis.into_inner(),
-                            z_axis.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat2",
-                |matrix2: Val<bevy::math::Mat2>| {
-                    let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_mat2(
-                            matrix2.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat2_translation",
-                |matrix2: Val<bevy::math::Mat2>, translation: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_mat2_translation(
-                            matrix2.into_inner(),
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat3",
-                |m: Val<bevy::math::Mat3>| {
-                    let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_mat3(
-                            m.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat3a",
-                |m: Val<bevy::math::Mat3A>| {
-                    let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_mat3a(
-                            m.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale",
-                |scale: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_scale(
-                            scale.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale_angle_translation",
-                |
-                    scale: Val<bevy::math::Vec2>,
-                    angle: f32,
-                    translation: Val<bevy::math::Vec2>|
-                {
-                    let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_scale_angle_translation(
-                            scale.into_inner(),
-                            angle,
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_translation",
-                |translation: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Affine2> = bevy::math::Affine2::from_translation(
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse",
-                |_self: Ref<bevy::math::Affine2>| {
-                    let output: Val<bevy::math::Affine2> = bevy::math::Affine2::inverse(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Ref<bevy::math::Affine2>| {
-                    let output: bool = bevy::math::Affine2::is_finite(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Ref<bevy::math::Affine2>| {
-                    let output: bool = bevy::math::Affine2::is_nan(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Affine2>, rhs: Val<bevy::math::Affine2>| {
-                    let output: Val<bevy::math::Affine2> = <bevy::math::Affine2 as std::ops::Mul<
-                        bevy::math::Affine2,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Affine2>, rhs: Val<bevy::math::Mat3>| {
-                    let output: Val<bevy::math::Mat3> = <bevy::math::Affine2 as std::ops::Mul<
-                        bevy::math::Mat3,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Affine2>, rhs: Val<bevy::math::Mat3A>| {
-                    let output: Val<bevy::math::Mat3A> = <bevy::math::Affine2 as std::ops::Mul<
-                        bevy::math::Mat3A,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array",
-                |_self: Ref<bevy::math::Affine2>| {
-                    let output: [f32; 6] = bevy::math::Affine2::to_cols_array(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array_2d",
-                |_self: Ref<bevy::math::Affine2>| {
-                    let output: [[f32; 2]; 3] = bevy::math::Affine2::to_cols_array_2d(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_point2",
-                |_self: Ref<bevy::math::Affine2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Affine2::transform_point2(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_vector2",
-                |_self: Ref<bevy::math::Affine2>, rhs: Val<bevy::math::Vec2>| {
-                    let output: Val<bevy::math::Vec2> = bevy::math::Affine2::transform_vector2(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::Affine3A>::new(world)
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Ref<bevy::math::Affine3A>,
-                    rhs: Val<bevy::math::Affine3A>,
-                    max_abs_diff: f32|
-                {
-                    let output: bool = bevy::math::Affine3A::abs_diff_eq(
-                            &_self,
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::Affine3A>| {
-                    let output: Val<bevy::math::Affine3A> = <bevy::math::Affine3A as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::Affine3A>, rhs: Ref<bevy::math::Affine3A>| {
-                    let output: bool = <bevy::math::Affine3A as std::cmp::PartialEq<
-                        bevy::math::Affine3A,
-                    >>::eq(&_self, &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_axis_angle",
-                |axis: Val<bevy::math::Vec3>, angle: f32| {
-                    let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_axis_angle(
-                            axis.into_inner(),
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_cols",
-                |
-                    x_axis: Val<bevy::math::Vec3A>,
-                    y_axis: Val<bevy::math::Vec3A>,
-                    z_axis: Val<bevy::math::Vec3A>,
-                    w_axis: Val<bevy::math::Vec3A>|
-                {
-                    let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_cols(
-                            x_axis.into_inner(),
-                            y_axis.into_inner(),
-                            z_axis.into_inner(),
-                            w_axis.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat3",
-                |mat3: Val<bevy::math::Mat3>| {
-                    let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_mat3(
-                            mat3.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat3_translation",
-                |mat3: Val<bevy::math::Mat3>, translation: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_mat3_translation(
-                            mat3.into_inner(),
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat4",
-                |m: Val<bevy::math::Mat4>| {
-                    let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_mat4(
-                            m.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_quat",
-                |rotation: Val<bevy::math::Quat>| {
-                    let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_quat(
-                            rotation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_translation",
-                |rotation: Val<bevy::math::Quat>, translation: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_rotation_translation(
-                            rotation.into_inner(),
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_x",
-                |angle: f32| {
-                    let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_rotation_x(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_y",
-                |angle: f32| {
-                    let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_rotation_y(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_z",
-                |angle: f32| {
-                    let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_rotation_z(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale",
-                |scale: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_scale(
-                            scale.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale_rotation_translation",
-                |
-                    scale: Val<bevy::math::Vec3>,
-                    rotation: Val<bevy::math::Quat>,
-                    translation: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_scale_rotation_translation(
-                            scale.into_inner(),
-                            rotation.into_inner(),
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_translation",
-                |translation: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::from_translation(
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse",
-                |_self: Ref<bevy::math::Affine3A>| {
-                    let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::inverse(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Ref<bevy::math::Affine3A>| {
-                    let output: bool = bevy::math::Affine3A::is_finite(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Ref<bevy::math::Affine3A>| {
-                    let output: bool = bevy::math::Affine3A::is_nan(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "look_at_lh",
-                |
-                    eye: Val<bevy::math::Vec3>,
-                    center: Val<bevy::math::Vec3>,
-                    up: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::look_at_lh(
-                            eye.into_inner(),
-                            center.into_inner(),
-                            up.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "look_at_rh",
-                |
-                    eye: Val<bevy::math::Vec3>,
-                    center: Val<bevy::math::Vec3>,
-                    up: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::look_at_rh(
-                            eye.into_inner(),
-                            center.into_inner(),
-                            up.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "look_to_lh",
-                |
-                    eye: Val<bevy::math::Vec3>,
-                    dir: Val<bevy::math::Vec3>,
-                    up: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::look_to_lh(
-                            eye.into_inner(),
-                            dir.into_inner(),
-                            up.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "look_to_rh",
-                |
-                    eye: Val<bevy::math::Vec3>,
-                    dir: Val<bevy::math::Vec3>,
-                    up: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::math::Affine3A> = bevy::math::Affine3A::look_to_rh(
-                            eye.into_inner(),
-                            dir.into_inner(),
-                            up.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Affine3A>, rhs: Val<bevy::math::Affine3A>| {
-                    let output: Val<bevy::math::Affine3A> = <bevy::math::Affine3A as std::ops::Mul<
-                        bevy::math::Affine3A,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::Affine3A>, rhs: Val<bevy::math::Mat4>| {
-                    let output: Val<bevy::math::Mat4> = <bevy::math::Affine3A as std::ops::Mul<
-                        bevy::math::Mat4,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array",
-                |_self: Ref<bevy::math::Affine3A>| {
-                    let output: [f32; 12] = bevy::math::Affine3A::to_cols_array(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array_2d",
-                |_self: Ref<bevy::math::Affine3A>| {
-                    let output: [[f32; 3]; 4] = bevy::math::Affine3A::to_cols_array_2d(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_point3",
-                |_self: Ref<bevy::math::Affine3A>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Affine3A::transform_point3(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_point3a",
-                |_self: Ref<bevy::math::Affine3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Affine3A::transform_point3a(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_vector3",
-                |_self: Ref<bevy::math::Affine3A>, rhs: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::math::Vec3> = bevy::math::Affine3A::transform_vector3(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_vector3a",
-                |_self: Ref<bevy::math::Affine3A>, rhs: Val<bevy::math::Vec3A>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::math::Affine3A::transform_vector3a(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::DAffine2>::new(world)
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Ref<bevy::math::DAffine2>,
-                    rhs: Val<bevy::math::DAffine2>,
-                    max_abs_diff: f64|
-                {
-                    let output: bool = bevy::math::DAffine2::abs_diff_eq(
-                            &_self,
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::DAffine2>| {
-                    let output: Val<bevy::math::DAffine2> = <bevy::math::DAffine2 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::DAffine2>, rhs: Ref<bevy::math::DAffine2>| {
-                    let output: bool = <bevy::math::DAffine2 as std::cmp::PartialEq<
-                        bevy::math::DAffine2,
-                    >>::eq(&_self, &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_angle",
-                |angle: f64| {
-                    let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::from_angle(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_angle_translation",
-                |angle: f64, translation: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::from_angle_translation(
-                            angle,
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_cols",
-                |
-                    x_axis: Val<bevy::math::DVec2>,
-                    y_axis: Val<bevy::math::DVec2>,
-                    z_axis: Val<bevy::math::DVec2>|
-                {
-                    let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::from_cols(
-                            x_axis.into_inner(),
-                            y_axis.into_inner(),
-                            z_axis.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat2",
-                |matrix2: Val<bevy::math::DMat2>| {
-                    let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::from_mat2(
-                            matrix2.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat2_translation",
-                |matrix2: Val<bevy::math::DMat2>, translation: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::from_mat2_translation(
-                            matrix2.into_inner(),
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat3",
-                |m: Val<bevy::math::DMat3>| {
-                    let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::from_mat3(
-                            m.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale",
-                |scale: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::from_scale(
-                            scale.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale_angle_translation",
-                |
-                    scale: Val<bevy::math::DVec2>,
-                    angle: f64,
-                    translation: Val<bevy::math::DVec2>|
-                {
-                    let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::from_scale_angle_translation(
-                            scale.into_inner(),
-                            angle,
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_translation",
-                |translation: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::from_translation(
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse",
-                |_self: Ref<bevy::math::DAffine2>| {
-                    let output: Val<bevy::math::DAffine2> = bevy::math::DAffine2::inverse(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Ref<bevy::math::DAffine2>| {
-                    let output: bool = bevy::math::DAffine2::is_finite(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Ref<bevy::math::DAffine2>| {
-                    let output: bool = bevy::math::DAffine2::is_nan(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DAffine2>, rhs: Val<bevy::math::DAffine2>| {
-                    let output: Val<bevy::math::DAffine2> = <bevy::math::DAffine2 as std::ops::Mul<
-                        bevy::math::DAffine2,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DAffine2>, rhs: Val<bevy::math::DMat3>| {
-                    let output: Val<bevy::math::DMat3> = <bevy::math::DAffine2 as std::ops::Mul<
-                        bevy::math::DMat3,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array",
-                |_self: Ref<bevy::math::DAffine2>| {
-                    let output: [f64; 6] = bevy::math::DAffine2::to_cols_array(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array_2d",
-                |_self: Ref<bevy::math::DAffine2>| {
-                    let output: [[f64; 2]; 3] = bevy::math::DAffine2::to_cols_array_2d(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_point2",
-                |_self: Ref<bevy::math::DAffine2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DAffine2::transform_point2(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_vector2",
-                |_self: Ref<bevy::math::DAffine2>, rhs: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DVec2> = bevy::math::DAffine2::transform_vector2(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::DAffine3>::new(world)
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Ref<bevy::math::DAffine3>,
-                    rhs: Val<bevy::math::DAffine3>,
-                    max_abs_diff: f64|
-                {
-                    let output: bool = bevy::math::DAffine3::abs_diff_eq(
-                            &_self,
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::DAffine3>| {
-                    let output: Val<bevy::math::DAffine3> = <bevy::math::DAffine3 as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::DAffine3>, rhs: Ref<bevy::math::DAffine3>| {
-                    let output: bool = <bevy::math::DAffine3 as std::cmp::PartialEq<
-                        bevy::math::DAffine3,
-                    >>::eq(&_self, &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_axis_angle",
-                |axis: Val<bevy::math::DVec3>, angle: f64| {
-                    let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_axis_angle(
-                            axis.into_inner(),
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_cols",
-                |
-                    x_axis: Val<bevy::math::DVec3>,
-                    y_axis: Val<bevy::math::DVec3>,
-                    z_axis: Val<bevy::math::DVec3>,
-                    w_axis: Val<bevy::math::DVec3>|
-                {
-                    let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_cols(
-                            x_axis.into_inner(),
-                            y_axis.into_inner(),
-                            z_axis.into_inner(),
-                            w_axis.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat3",
-                |mat3: Val<bevy::math::DMat3>| {
-                    let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_mat3(
-                            mat3.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat3_translation",
-                |mat3: Val<bevy::math::DMat3>, translation: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_mat3_translation(
-                            mat3.into_inner(),
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat4",
-                |m: Val<bevy::math::DMat4>| {
-                    let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_mat4(
-                            m.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_quat",
-                |rotation: Val<bevy::math::DQuat>| {
-                    let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_quat(
-                            rotation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_translation",
-                |rotation: Val<bevy::math::DQuat>, translation: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_rotation_translation(
-                            rotation.into_inner(),
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_x",
-                |angle: f64| {
-                    let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_rotation_x(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_y",
-                |angle: f64| {
-                    let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_rotation_y(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_z",
-                |angle: f64| {
-                    let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_rotation_z(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale",
-                |scale: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_scale(
-                            scale.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale_rotation_translation",
-                |
-                    scale: Val<bevy::math::DVec3>,
-                    rotation: Val<bevy::math::DQuat>,
-                    translation: Val<bevy::math::DVec3>|
-                {
-                    let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_scale_rotation_translation(
-                            scale.into_inner(),
-                            rotation.into_inner(),
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_translation",
-                |translation: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::from_translation(
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse",
-                |_self: Ref<bevy::math::DAffine3>| {
-                    let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::inverse(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Ref<bevy::math::DAffine3>| {
-                    let output: bool = bevy::math::DAffine3::is_finite(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Ref<bevy::math::DAffine3>| {
-                    let output: bool = bevy::math::DAffine3::is_nan(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "look_at_lh",
-                |
-                    eye: Val<bevy::math::DVec3>,
-                    center: Val<bevy::math::DVec3>,
-                    up: Val<bevy::math::DVec3>|
-                {
-                    let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::look_at_lh(
-                            eye.into_inner(),
-                            center.into_inner(),
-                            up.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "look_at_rh",
-                |
-                    eye: Val<bevy::math::DVec3>,
-                    center: Val<bevy::math::DVec3>,
-                    up: Val<bevy::math::DVec3>|
-                {
-                    let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::look_at_rh(
-                            eye.into_inner(),
-                            center.into_inner(),
-                            up.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "look_to_lh",
-                |
-                    eye: Val<bevy::math::DVec3>,
-                    dir: Val<bevy::math::DVec3>,
-                    up: Val<bevy::math::DVec3>|
-                {
-                    let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::look_to_lh(
-                            eye.into_inner(),
-                            dir.into_inner(),
-                            up.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "look_to_rh",
-                |
-                    eye: Val<bevy::math::DVec3>,
-                    dir: Val<bevy::math::DVec3>,
-                    up: Val<bevy::math::DVec3>|
-                {
-                    let output: Val<bevy::math::DAffine3> = bevy::math::DAffine3::look_to_rh(
-                            eye.into_inner(),
-                            dir.into_inner(),
-                            up.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DAffine3>, rhs: Val<bevy::math::DAffine3>| {
-                    let output: Val<bevy::math::DAffine3> = <bevy::math::DAffine3 as std::ops::Mul<
-                        bevy::math::DAffine3,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DAffine3>, rhs: Val<bevy::math::DMat4>| {
-                    let output: Val<bevy::math::DMat4> = <bevy::math::DAffine3 as std::ops::Mul<
-                        bevy::math::DMat4,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array",
-                |_self: Ref<bevy::math::DAffine3>| {
-                    let output: [f64; 12] = bevy::math::DAffine3::to_cols_array(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_cols_array_2d",
-                |_self: Ref<bevy::math::DAffine3>| {
-                    let output: [[f64; 3]; 4] = bevy::math::DAffine3::to_cols_array_2d(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_point3",
-                |_self: Ref<bevy::math::DAffine3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DAffine3::transform_point3(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_vector3",
-                |_self: Ref<bevy::math::DAffine3>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DAffine3::transform_vector3(
-                            &_self,
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::DQuat>::new(world)
-            .register(
-                "abs_diff_eq",
-                |
-                    _self: Val<bevy::math::DQuat>,
-                    rhs: Val<bevy::math::DQuat>,
-                    max_abs_diff: f64|
-                {
-                    let output: bool = bevy::math::DQuat::abs_diff_eq(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                            max_abs_diff,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "add",
-                |_self: Val<bevy::math::DQuat>, rhs: Val<bevy::math::DQuat>| {
-                    let output: Val<bevy::math::DQuat> = <bevy::math::DQuat as std::ops::Add<
-                        bevy::math::DQuat,
-                    >>::add(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "angle_between",
-                |_self: Val<bevy::math::DQuat>, rhs: Val<bevy::math::DQuat>| {
-                    let output: f64 = bevy::math::DQuat::angle_between(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "as_quat",
-                |_self: Val<bevy::math::DQuat>| {
-                    let output: Val<bevy::math::Quat> = bevy::math::DQuat::as_quat(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::DQuat>| {
-                    let output: Val<bevy::math::DQuat> = <bevy::math::DQuat as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "conjugate",
-                |_self: Val<bevy::math::DQuat>| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::conjugate(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "div",
-                |_self: Val<bevy::math::DQuat>, rhs: f64| {
-                    let output: Val<bevy::math::DQuat> = <bevy::math::DQuat as std::ops::Div<
-                        f64,
-                    >>::div(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "dot",
-                |_self: Val<bevy::math::DQuat>, rhs: Val<bevy::math::DQuat>| {
-                    let output: f64 = bevy::math::DQuat::dot(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::DQuat>, rhs: Ref<bevy::math::DQuat>| {
-                    let output: bool = <bevy::math::DQuat as std::cmp::PartialEq<
-                        bevy::math::DQuat,
-                    >>::eq(&_self, &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_affine3",
-                |a: Ref<bevy::math::DAffine3>| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_affine3(
-                            &a,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [f64; 4]| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_array(a)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_axis_angle",
-                |axis: Val<bevy::math::DVec3>, angle: f64| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_axis_angle(
-                            axis.into_inner(),
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_euler",
-                |euler: Val<bevy::math::EulerRot>, a: f64, b: f64, c: f64| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_euler(
-                            euler.into_inner(),
-                            a,
-                            b,
-                            c,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat3",
-                |mat: Ref<bevy::math::DMat3>| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_mat3(
-                            &mat,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_mat4",
-                |mat: Ref<bevy::math::DMat4>| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_mat4(
-                            &mat,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_arc",
-                |from: Val<bevy::math::DVec3>, to: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_rotation_arc(
-                            from.into_inner(),
-                            to.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_arc_2d",
-                |from: Val<bevy::math::DVec2>, to: Val<bevy::math::DVec2>| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_rotation_arc_2d(
-                            from.into_inner(),
-                            to.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_arc_colinear",
-                |from: Val<bevy::math::DVec3>, to: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_rotation_arc_colinear(
-                            from.into_inner(),
-                            to.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_x",
-                |angle: f64| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_rotation_x(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_y",
-                |angle: f64| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_rotation_y(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation_z",
-                |angle: f64| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_rotation_z(
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scaled_axis",
-                |v: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_scaled_axis(
-                            v.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_vec4",
-                |v: Val<bevy::math::DVec4>| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_vec4(
-                            v.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_xyzw",
-                |x: f64, y: f64, z: f64, w: f64| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::from_xyzw(
-                            x,
-                            y,
-                            z,
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "inverse",
-                |_self: Val<bevy::math::DQuat>| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::inverse(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Val<bevy::math::DQuat>| {
-                    let output: bool = bevy::math::DQuat::is_finite(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_nan",
-                |_self: Val<bevy::math::DQuat>| {
-                    let output: bool = bevy::math::DQuat::is_nan(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_near_identity",
-                |_self: Val<bevy::math::DQuat>| {
-                    let output: bool = bevy::math::DQuat::is_near_identity(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_normalized",
-                |_self: Val<bevy::math::DQuat>| {
-                    let output: bool = bevy::math::DQuat::is_normalized(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length",
-                |_self: Val<bevy::math::DQuat>| {
-                    let output: f64 = bevy::math::DQuat::length(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_recip",
-                |_self: Val<bevy::math::DQuat>| {
-                    let output: f64 = bevy::math::DQuat::length_recip(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "length_squared",
-                |_self: Val<bevy::math::DQuat>| {
-                    let output: f64 = bevy::math::DQuat::length_squared(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "lerp",
-                |_self: Val<bevy::math::DQuat>, end: Val<bevy::math::DQuat>, s: f64| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::lerp(
-                            _self.into_inner(),
-                            end.into_inner(),
-                            s,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DQuat>, rhs: Val<bevy::math::DQuat>| {
-                    let output: Val<bevy::math::DQuat> = <bevy::math::DQuat as std::ops::Mul<
-                        bevy::math::DQuat,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DQuat>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = <bevy::math::DQuat as std::ops::Mul<
-                        bevy::math::DVec3,
-                    >>::mul(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |_self: Val<bevy::math::DQuat>, rhs: f64| {
-                    let output: Val<bevy::math::DQuat> = <bevy::math::DQuat as std::ops::Mul<
-                        f64,
-                    >>::mul(_self.into_inner(), rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_quat",
-                |_self: Val<bevy::math::DQuat>, rhs: Val<bevy::math::DQuat>| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::mul_quat(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_vec3",
-                |_self: Val<bevy::math::DQuat>, rhs: Val<bevy::math::DVec3>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DQuat::mul_vec3(
-                            _self.into_inner(),
-                            rhs.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "neg",
-                |_self: Val<bevy::math::DQuat>| {
-                    let output: Val<bevy::math::DQuat> = <bevy::math::DQuat as std::ops::Neg>::neg(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "normalize",
-                |_self: Val<bevy::math::DQuat>| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::normalize(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotate_towards",
-                |
-                    _self: Ref<bevy::math::DQuat>,
-                    rhs: Val<bevy::math::DQuat>,
-                    max_angle: f64|
-                {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::rotate_towards(
-                            &_self,
-                            rhs.into_inner(),
-                            max_angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "slerp",
-                |_self: Val<bevy::math::DQuat>, end: Val<bevy::math::DQuat>, s: f64| {
-                    let output: Val<bevy::math::DQuat> = bevy::math::DQuat::slerp(
-                            _self.into_inner(),
-                            end.into_inner(),
-                            s,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "sub",
-                |_self: Val<bevy::math::DQuat>, rhs: Val<bevy::math::DQuat>| {
-                    let output: Val<bevy::math::DQuat> = <bevy::math::DQuat as std::ops::Sub<
-                        bevy::math::DQuat,
-                    >>::sub(_self.into_inner(), rhs.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_array",
-                |_self: Ref<bevy::math::DQuat>| {
-                    let output: [f64; 4] = bevy::math::DQuat::to_array(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "to_euler",
-                |_self: Val<bevy::math::DQuat>, order: Val<bevy::math::EulerRot>| {
-                    let output: (f64, f64, f64) = bevy::math::DQuat::to_euler(
-                            _self.into_inner(),
-                            order.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_scaled_axis",
-                |_self: Val<bevy::math::DQuat>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DQuat::to_scaled_axis(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "xyz",
-                |_self: Val<bevy::math::DQuat>| {
-                    let output: Val<bevy::math::DVec3> = bevy::math::DQuat::xyz(
-                            _self.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::EulerRot>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::math::EulerRot>| {
-                    let output: () = <bevy::math::EulerRot as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::EulerRot>| {
-                    let output: Val<bevy::math::EulerRot> = <bevy::math::EulerRot as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::EulerRot>, other: Ref<bevy::math::EulerRot>| {
-                    let output: bool = <bevy::math::EulerRot as std::cmp::PartialEq<
-                        bevy::math::EulerRot,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::BVec3A>::new(world)
-            .register(
-                "all",
-                |_self: Val<bevy::math::BVec3A>| {
-                    let output: bool = bevy::math::BVec3A::all(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "any",
-                |_self: Val<bevy::math::BVec3A>| {
-                    let output: bool = bevy::math::BVec3A::any(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "bitmask",
-                |_self: Val<bevy::math::BVec3A>| {
-                    let output: u32 = bevy::math::BVec3A::bitmask(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::BVec3A>| {
-                    let output: Val<bevy::math::BVec3A> = <bevy::math::BVec3A as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::BVec3A>, rhs: Ref<bevy::math::BVec3A>| {
-                    let output: bool = <bevy::math::BVec3A as std::cmp::PartialEq<
-                        bevy::math::BVec3A,
-                    >>::eq(&_self, &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [bool; 3]| {
-                    let output: Val<bevy::math::BVec3A> = bevy::math::BVec3A::from_array(
-                            a,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: bool, y: bool, z: bool| {
-                    let output: Val<bevy::math::BVec3A> = bevy::math::BVec3A::new(
-                            x,
-                            y,
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "set",
-                |mut _self: Mut<bevy::math::BVec3A>, index: usize, value: bool| {
-                    let output: () = bevy::math::BVec3A::set(&mut _self, index, value)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: bool| {
-                    let output: Val<bevy::math::BVec3A> = bevy::math::BVec3A::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "test",
-                |_self: Ref<bevy::math::BVec3A>, index: usize| {
-                    let output: bool = bevy::math::BVec3A::test(&_self, index).into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::math::BVec4A>::new(world)
-            .register(
-                "all",
-                |_self: Val<bevy::math::BVec4A>| {
-                    let output: bool = bevy::math::BVec4A::all(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "any",
-                |_self: Val<bevy::math::BVec4A>| {
-                    let output: bool = bevy::math::BVec4A::any(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "bitmask",
-                |_self: Val<bevy::math::BVec4A>| {
-                    let output: u32 = bevy::math::BVec4A::bitmask(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::math::BVec4A>| {
-                    let output: Val<bevy::math::BVec4A> = <bevy::math::BVec4A as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<bevy::math::BVec4A>, rhs: Ref<bevy::math::BVec4A>| {
-                    let output: bool = <bevy::math::BVec4A as std::cmp::PartialEq<
-                        bevy::math::BVec4A,
-                    >>::eq(&_self, &rhs)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_array",
-                |a: [bool; 4]| {
-                    let output: Val<bevy::math::BVec4A> = bevy::math::BVec4A::from_array(
-                            a,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |x: bool, y: bool, z: bool, w: bool| {
-                    let output: Val<bevy::math::BVec4A> = bevy::math::BVec4A::new(
-                            x,
-                            y,
-                            z,
-                            w,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "set",
-                |mut _self: Mut<bevy::math::BVec4A>, index: usize, value: bool| {
-                    let output: () = bevy::math::BVec4A::set(&mut _self, index, value)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "splat",
-                |v: bool| {
-                    let output: Val<bevy::math::BVec4A> = bevy::math::BVec4A::splat(v)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "test",
-                |_self: Ref<bevy::math::BVec4A>, index: usize| {
-                    let output: bool = bevy::math::BVec4A::test(&_self, index).into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::smol_str::SmolStr>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<smol_str::SmolStr>| {
-                    let output: Val<smol_str::SmolStr> = <smol_str::SmolStr as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<smol_str::SmolStr>, other: Ref<smol_str::SmolStr>| {
-                    let output: bool = <smol_str::SmolStr as std::cmp::PartialEq<
-                        smol_str::SmolStr,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_empty",
-                |_self: Ref<smol_str::SmolStr>| {
-                    let output: bool = smol_str::SmolStr::is_empty(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "is_heap_allocated",
-                |_self: Ref<smol_str::SmolStr>| {
-                    let output: bool = smol_str::SmolStr::is_heap_allocated(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "len",
-                |_self: Ref<smol_str::SmolStr>| {
-                    let output: usize = smol_str::SmolStr::len(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "to_string",
-                |_self: Ref<smol_str::SmolStr>| {
-                    let output: std::string::String = smol_str::SmolStr::to_string(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::uuid::Uuid>::new(world)
-            .register(
-                "as_u128",
-                |_self: Ref<uuid::Uuid>| {
-                    let output: u128 = uuid::Uuid::as_u128(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "as_u64_pair",
-                |_self: Ref<uuid::Uuid>| {
-                    let output: (u64, u64) = uuid::Uuid::as_u64_pair(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<uuid::Uuid>| {
-                    let output: () = <uuid::Uuid as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<uuid::Uuid>| {
-                    let output: Val<uuid::Uuid> = <uuid::Uuid as bevy::reflect::erased_serde::__private::serde::__private::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "encode_buffer",
-                || {
-                    let output: [u8; 45] = uuid::Uuid::encode_buffer().into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |_self: Ref<uuid::Uuid>, other: Ref<uuid::Uuid>| {
-                    let output: bool = <uuid::Uuid as std::cmp::PartialEq<
-                        uuid::Uuid,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_bytes",
-                |bytes: [u8; 16]| {
-                    let output: Val<uuid::Uuid> = uuid::Uuid::from_bytes(bytes).into();
-                    output
-                },
-            )
-            .register(
-                "from_bytes_le",
-                |b: [u8; 16]| {
-                    let output: Val<uuid::Uuid> = uuid::Uuid::from_bytes_le(b).into();
-                    output
-                },
-            )
-            .register(
-                "from_u128",
-                |v: u128| {
-                    let output: Val<uuid::Uuid> = uuid::Uuid::from_u128(v).into();
-                    output
-                },
-            )
-            .register(
-                "from_u128_le",
-                |v: u128| {
-                    let output: Val<uuid::Uuid> = uuid::Uuid::from_u128_le(v).into();
-                    output
-                },
-            )
-            .register(
-                "from_u64_pair",
-                |high_bits: u64, low_bits: u64| {
-                    let output: Val<uuid::Uuid> = uuid::Uuid::from_u64_pair(
-                            high_bits,
-                            low_bits,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "get_node_id",
-                |_self: Ref<uuid::Uuid>| {
-                    let output: bevy::reflect::erased_serde::__private::serde::__private::Option<
-                        [u8; 6],
-                    > = uuid::Uuid::get_node_id(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "get_version_num",
-                |_self: Ref<uuid::Uuid>| {
-                    let output: usize = uuid::Uuid::get_version_num(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "into_bytes",
-                |_self: Val<uuid::Uuid>| {
-                    let output: [u8; 16] = uuid::Uuid::into_bytes(_self.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_max",
-                |_self: Ref<uuid::Uuid>| {
-                    let output: bool = uuid::Uuid::is_max(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "is_nil",
-                |_self: Ref<uuid::Uuid>| {
-                    let output: bool = uuid::Uuid::is_nil(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "max",
-                || {
-                    let output: Val<uuid::Uuid> = uuid::Uuid::max().into();
-                    output
-                },
-            )
-            .register(
-                "new_v4",
-                || {
-                    let output: Val<uuid::Uuid> = uuid::Uuid::new_v4().into();
-                    output
-                },
-            )
-            .register(
-                "nil",
-                || {
-                    let output: Val<uuid::Uuid> = uuid::Uuid::nil().into();
-                    output
-                },
-            )
-            .register(
-                "to_bytes_le",
-                |_self: Ref<uuid::Uuid>| {
-                    let output: [u8; 16] = uuid::Uuid::to_bytes_le(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "to_u128_le",
-                |_self: Ref<uuid::Uuid>| {
-                    let output: u128 = uuid::Uuid::to_u128_le(&_self).into();
-                    output
-                },
-            );
+        register_atomic_bool(&mut world);
+        register_atomic_i_16(&mut world);
+        register_atomic_i_32(&mut world);
+        register_atomic_i_64(&mut world);
+        register_atomic_i_8(&mut world);
+        register_atomic_isize(&mut world);
+        register_atomic_u_16(&mut world);
+        register_atomic_u_32(&mut world);
+        register_atomic_u_64(&mut world);
+        register_atomic_u_8(&mut world);
+        register_atomic_usize(&mut world);
+        register_duration(&mut world);
+        register_instant(&mut world);
+        register_range_full(&mut world);
+        register_quat(&mut world);
+        register_vec_3(&mut world);
+        register_i_vec_2(&mut world);
+        register_i_vec_3(&mut world);
+        register_i_vec_4(&mut world);
+        register_i_64_vec_2(&mut world);
+        register_i_64_vec_3(&mut world);
+        register_i_64_vec_4(&mut world);
+        register_u_vec_2(&mut world);
+        register_u_vec_3(&mut world);
+        register_u_vec_4(&mut world);
+        register_u_64_vec_2(&mut world);
+        register_u_64_vec_3(&mut world);
+        register_u_64_vec_4(&mut world);
+        register_vec_2(&mut world);
+        register_vec_3_a(&mut world);
+        register_vec_4(&mut world);
+        register_b_vec_2(&mut world);
+        register_b_vec_3(&mut world);
+        register_b_vec_4(&mut world);
+        register_d_vec_2(&mut world);
+        register_d_vec_3(&mut world);
+        register_d_vec_4(&mut world);
+        register_mat_2(&mut world);
+        register_mat_3(&mut world);
+        register_mat_3_a(&mut world);
+        register_mat_4(&mut world);
+        register_d_mat_2(&mut world);
+        register_d_mat_3(&mut world);
+        register_d_mat_4(&mut world);
+        register_affine_2(&mut world);
+        register_affine_3_a(&mut world);
+        register_d_affine_2(&mut world);
+        register_d_affine_3(&mut world);
+        register_d_quat(&mut world);
+        register_euler_rot(&mut world);
+        register_b_vec_3_a(&mut world);
+        register_b_vec_4_a(&mut world);
+        register_smol_str(&mut world);
+        register_uuid(&mut world);
     }
 }
diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_time.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_time.rs
index 1118b34f0a..a3b69ec93c 100644
--- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_time.rs
+++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_time.rs
@@ -9,425 +9,298 @@ use bevy_mod_scripting_core::bindings::{
         namespace::NamespaceBuilder,
     },
 };
+use bevy_mod_scripting_derive::script_bindings;
 use crate::*;
 pub struct BevyTimeScriptingPlugin;
-impl ::bevy::app::Plugin for BevyTimeScriptingPlugin {
-    fn build(&self, app: &mut ::bevy::prelude::App) {
-        let mut world = app.world_mut();
-        NamespaceBuilder::<::bevy::time::prelude::Fixed>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::time::prelude::Fixed>| {
-                    let output: Val<bevy::time::prelude::Fixed> = <bevy::time::prelude::Fixed as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::time::prelude::Real>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::time::prelude::Real>| {
-                    let output: Val<bevy::time::prelude::Real> = <bevy::time::prelude::Real as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::time::prelude::Timer>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::time::prelude::Timer>| {
-                    let output: () = <bevy::time::prelude::Timer as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::time::prelude::Timer>| {
-                    let output: Val<bevy::time::prelude::Timer> = <bevy::time::prelude::Timer as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "duration",
-                |_self: Ref<bevy::time::prelude::Timer>| {
-                    let output: Val<bevy::utils::Duration> = bevy::time::prelude::Timer::duration(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "elapsed",
-                |_self: Ref<bevy::time::prelude::Timer>| {
-                    let output: Val<bevy::utils::Duration> = bevy::time::prelude::Timer::elapsed(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "elapsed_secs",
-                |_self: Ref<bevy::time::prelude::Timer>| {
-                    let output: f32 = bevy::time::prelude::Timer::elapsed_secs(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "elapsed_secs_f64",
-                |_self: Ref<bevy::time::prelude::Timer>| {
-                    let output: f64 = bevy::time::prelude::Timer::elapsed_secs_f64(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::time::prelude::Timer>,
-                    other: Ref<bevy::time::prelude::Timer>|
-                {
-                    let output: bool = <bevy::time::prelude::Timer as std::cmp::PartialEq<
-                        bevy::time::prelude::Timer,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "finished",
-                |_self: Ref<bevy::time::prelude::Timer>| {
-                    let output: bool = bevy::time::prelude::Timer::finished(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fraction",
-                |_self: Ref<bevy::time::prelude::Timer>| {
-                    let output: f32 = bevy::time::prelude::Timer::fraction(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "fraction_remaining",
-                |_self: Ref<bevy::time::prelude::Timer>| {
-                    let output: f32 = bevy::time::prelude::Timer::fraction_remaining(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_seconds",
-                |duration: f32, mode: Val<bevy::time::prelude::TimerMode>| {
-                    let output: Val<bevy::time::prelude::Timer> = bevy::time::prelude::Timer::from_seconds(
-                            duration,
-                            mode.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "just_finished",
-                |_self: Ref<bevy::time::prelude::Timer>| {
-                    let output: bool = bevy::time::prelude::Timer::just_finished(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mode",
-                |_self: Ref<bevy::time::prelude::Timer>| {
-                    let output: Val<bevy::time::prelude::TimerMode> = bevy::time::prelude::Timer::mode(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "new",
-                |
-                    duration: Val<bevy::utils::Duration>,
-                    mode: Val<bevy::time::prelude::TimerMode>|
-                {
-                    let output: Val<bevy::time::prelude::Timer> = bevy::time::prelude::Timer::new(
-                            duration.into_inner(),
-                            mode.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "pause",
-                |mut _self: Mut<bevy::time::prelude::Timer>| {
-                    let output: () = bevy::time::prelude::Timer::pause(&mut _self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "paused",
-                |_self: Ref<bevy::time::prelude::Timer>| {
-                    let output: bool = bevy::time::prelude::Timer::paused(&_self).into();
-                    output
-                },
-            )
-            .register(
-                "remaining",
-                |_self: Ref<bevy::time::prelude::Timer>| {
-                    let output: Val<bevy::utils::Duration> = bevy::time::prelude::Timer::remaining(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "remaining_secs",
-                |_self: Ref<bevy::time::prelude::Timer>| {
-                    let output: f32 = bevy::time::prelude::Timer::remaining_secs(&_self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reset",
-                |mut _self: Mut<bevy::time::prelude::Timer>| {
-                    let output: () = bevy::time::prelude::Timer::reset(&mut _self)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "set_duration",
-                |
-                    mut _self: Mut<bevy::time::prelude::Timer>,
-                    duration: Val<bevy::utils::Duration>|
-                {
-                    let output: () = bevy::time::prelude::Timer::set_duration(
-                            &mut _self,
-                            duration.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "set_elapsed",
-                |
-                    mut _self: Mut<bevy::time::prelude::Timer>,
-                    time: Val<bevy::utils::Duration>|
-                {
-                    let output: () = bevy::time::prelude::Timer::set_elapsed(
-                            &mut _self,
-                            time.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "set_mode",
-                |
-                    mut _self: Mut<bevy::time::prelude::Timer>,
-                    mode: Val<bevy::time::prelude::TimerMode>|
-                {
-                    let output: () = bevy::time::prelude::Timer::set_mode(
-                            &mut _self,
-                            mode.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "times_finished_this_tick",
-                |_self: Ref<bevy::time::prelude::Timer>| {
-                    let output: u32 = bevy::time::prelude::Timer::times_finished_this_tick(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "unpause",
-                |mut _self: Mut<bevy::time::prelude::Timer>| {
-                    let output: () = bevy::time::prelude::Timer::unpause(&mut _self)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::time::prelude::TimerMode>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::time::prelude::TimerMode>| {
-                    let output: () = <bevy::time::prelude::TimerMode as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::time::prelude::TimerMode>| {
-                    let output: Val<bevy::time::prelude::TimerMode> = <bevy::time::prelude::TimerMode as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::time::prelude::TimerMode>,
-                    other: Ref<bevy::time::prelude::TimerMode>|
-                {
-                    let output: bool = <bevy::time::prelude::TimerMode as std::cmp::PartialEq<
-                        bevy::time::prelude::TimerMode,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::time::prelude::Virtual>::new(world)
-            .register(
-                "clone",
-                |_self: Ref<bevy::time::prelude::Virtual>| {
-                    let output: Val<bevy::time::prelude::Virtual> = <bevy::time::prelude::Virtual as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::time::Stopwatch>::new(world)
-            .register(
-                "assert_receiver_is_total_eq",
-                |_self: Ref<bevy::time::Stopwatch>| {
-                    let output: () = <bevy::time::Stopwatch as std::cmp::Eq>::assert_receiver_is_total_eq(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::time::Stopwatch>| {
-                    let output: Val<bevy::time::Stopwatch> = <bevy::time::Stopwatch as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "elapsed",
-                |_self: Ref<bevy::time::Stopwatch>| {
-                    let output: Val<bevy::utils::Duration> = bevy::time::Stopwatch::elapsed(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "elapsed_secs",
-                |_self: Ref<bevy::time::Stopwatch>| {
-                    let output: f32 = bevy::time::Stopwatch::elapsed_secs(&_self).into();
-                    output
-                },
+#[script_bindings(remote, name = "fixed")]
+impl bevy::time::prelude::Fixed {
+    fn clone(_self: Ref<bevy::time::prelude::Fixed>) {
+        let output: Val<bevy::time::prelude::Fixed> = <bevy::time::prelude::Fixed as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "real")]
+impl bevy::time::prelude::Real {
+    fn clone(_self: Ref<bevy::time::prelude::Real>) {
+        let output: Val<bevy::time::prelude::Real> = <bevy::time::prelude::Real as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "timer")]
+impl bevy::time::prelude::Timer {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::time::prelude::Timer>) {
+        let output: () = <bevy::time::prelude::Timer as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::time::prelude::Timer>) {
+        let output: Val<bevy::time::prelude::Timer> = <bevy::time::prelude::Timer as std::clone::Clone>::clone(
+                &_self,
             )
-            .register(
-                "elapsed_secs_f64",
-                |_self: Ref<bevy::time::Stopwatch>| {
-                    let output: f64 = bevy::time::Stopwatch::elapsed_secs_f64(&_self)
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn duration(_self: Ref<bevy::time::prelude::Timer>) {
+        let output: Val<bevy::utils::Duration> = bevy::time::prelude::Timer::duration(
+                &_self,
             )
-            .register(
-                "eq",
-                |_self: Ref<bevy::time::Stopwatch>, other: Ref<bevy::time::Stopwatch>| {
-                    let output: bool = <bevy::time::Stopwatch as std::cmp::PartialEq<
-                        bevy::time::Stopwatch,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn elapsed(_self: Ref<bevy::time::prelude::Timer>) {
+        let output: Val<bevy::utils::Duration> = bevy::time::prelude::Timer::elapsed(
+                &_self,
             )
-            .register(
-                "is_paused",
-                |_self: Ref<bevy::time::Stopwatch>| {
-                    let output: bool = bevy::time::Stopwatch::is_paused(&_self).into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn elapsed_secs(_self: Ref<bevy::time::prelude::Timer>) {
+        let output: f32 = bevy::time::prelude::Timer::elapsed_secs(&_self).into();
+        output
+    }
+    fn elapsed_secs_f64(_self: Ref<bevy::time::prelude::Timer>) {
+        let output: f64 = bevy::time::prelude::Timer::elapsed_secs_f64(&_self).into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::time::prelude::Timer>,
+        other: Ref<bevy::time::prelude::Timer>,
+    ) {
+        let output: bool = <bevy::time::prelude::Timer as std::cmp::PartialEq<
+            bevy::time::prelude::Timer,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn finished(_self: Ref<bevy::time::prelude::Timer>) {
+        let output: bool = bevy::time::prelude::Timer::finished(&_self).into();
+        output
+    }
+    fn fraction(_self: Ref<bevy::time::prelude::Timer>) {
+        let output: f32 = bevy::time::prelude::Timer::fraction(&_self).into();
+        output
+    }
+    fn fraction_remaining(_self: Ref<bevy::time::prelude::Timer>) {
+        let output: f32 = bevy::time::prelude::Timer::fraction_remaining(&_self).into();
+        output
+    }
+    fn from_seconds(duration: f32, mode: Val<bevy::time::prelude::TimerMode>) {
+        let output: Val<bevy::time::prelude::Timer> = bevy::time::prelude::Timer::from_seconds(
+                duration,
+                mode.into_inner(),
             )
-            .register(
-                "new",
-                || {
-                    let output: Val<bevy::time::Stopwatch> = bevy::time::Stopwatch::new()
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn just_finished(_self: Ref<bevy::time::prelude::Timer>) {
+        let output: bool = bevy::time::prelude::Timer::just_finished(&_self).into();
+        output
+    }
+    fn mode(_self: Ref<bevy::time::prelude::Timer>) {
+        let output: Val<bevy::time::prelude::TimerMode> = bevy::time::prelude::Timer::mode(
+                &_self,
             )
-            .register(
-                "pause",
-                |mut _self: Mut<bevy::time::Stopwatch>| {
-                    let output: () = bevy::time::Stopwatch::pause(&mut _self).into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn new(
+        duration: Val<bevy::utils::Duration>,
+        mode: Val<bevy::time::prelude::TimerMode>,
+    ) {
+        let output: Val<bevy::time::prelude::Timer> = bevy::time::prelude::Timer::new(
+                duration.into_inner(),
+                mode.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn pause(mut _self: Mut<bevy::time::prelude::Timer>) {
+        let output: () = bevy::time::prelude::Timer::pause(&mut _self).into();
+        output
+    }
+    fn paused(_self: Ref<bevy::time::prelude::Timer>) {
+        let output: bool = bevy::time::prelude::Timer::paused(&_self).into();
+        output
+    }
+    fn remaining(_self: Ref<bevy::time::prelude::Timer>) {
+        let output: Val<bevy::utils::Duration> = bevy::time::prelude::Timer::remaining(
+                &_self,
             )
-            .register(
-                "reset",
-                |mut _self: Mut<bevy::time::Stopwatch>| {
-                    let output: () = bevy::time::Stopwatch::reset(&mut _self).into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn remaining_secs(_self: Ref<bevy::time::prelude::Timer>) {
+        let output: f32 = bevy::time::prelude::Timer::remaining_secs(&_self).into();
+        output
+    }
+    fn reset(mut _self: Mut<bevy::time::prelude::Timer>) {
+        let output: () = bevy::time::prelude::Timer::reset(&mut _self).into();
+        output
+    }
+    fn set_duration(
+        mut _self: Mut<bevy::time::prelude::Timer>,
+        duration: Val<bevy::utils::Duration>,
+    ) {
+        let output: () = bevy::time::prelude::Timer::set_duration(
+                &mut _self,
+                duration.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn set_elapsed(
+        mut _self: Mut<bevy::time::prelude::Timer>,
+        time: Val<bevy::utils::Duration>,
+    ) {
+        let output: () = bevy::time::prelude::Timer::set_elapsed(
+                &mut _self,
+                time.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn set_mode(
+        mut _self: Mut<bevy::time::prelude::Timer>,
+        mode: Val<bevy::time::prelude::TimerMode>,
+    ) {
+        let output: () = bevy::time::prelude::Timer::set_mode(
+                &mut _self,
+                mode.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn times_finished_this_tick(_self: Ref<bevy::time::prelude::Timer>) {
+        let output: u32 = bevy::time::prelude::Timer::times_finished_this_tick(&_self)
+            .into();
+        output
+    }
+    fn unpause(mut _self: Mut<bevy::time::prelude::Timer>) {
+        let output: () = bevy::time::prelude::Timer::unpause(&mut _self).into();
+        output
+    }
+}
+#[script_bindings(remote, name = "timer_mode")]
+impl bevy::time::prelude::TimerMode {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::time::prelude::TimerMode>) {
+        let output: () = <bevy::time::prelude::TimerMode as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::time::prelude::TimerMode>) {
+        let output: Val<bevy::time::prelude::TimerMode> = <bevy::time::prelude::TimerMode as std::clone::Clone>::clone(
+                &_self,
             )
-            .register(
-                "set_elapsed",
-                |
-                    mut _self: Mut<bevy::time::Stopwatch>,
-                    time: Val<bevy::utils::Duration>|
-                {
-                    let output: () = bevy::time::Stopwatch::set_elapsed(
-                            &mut _self,
-                            time.into_inner(),
-                        )
-                        .into();
-                    output
-                },
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::time::prelude::TimerMode>,
+        other: Ref<bevy::time::prelude::TimerMode>,
+    ) {
+        let output: bool = <bevy::time::prelude::TimerMode as std::cmp::PartialEq<
+            bevy::time::prelude::TimerMode,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "virtual")]
+impl bevy::time::prelude::Virtual {
+    fn clone(_self: Ref<bevy::time::prelude::Virtual>) {
+        let output: Val<bevy::time::prelude::Virtual> = <bevy::time::prelude::Virtual as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "stopwatch")]
+impl bevy::time::Stopwatch {
+    fn assert_receiver_is_total_eq(_self: Ref<bevy::time::Stopwatch>) {
+        let output: () = <bevy::time::Stopwatch as std::cmp::Eq>::assert_receiver_is_total_eq(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::time::Stopwatch>) {
+        let output: Val<bevy::time::Stopwatch> = <bevy::time::Stopwatch as std::clone::Clone>::clone(
+                &_self,
             )
-            .register(
-                "unpause",
-                |mut _self: Mut<bevy::time::Stopwatch>| {
-                    let output: () = bevy::time::Stopwatch::unpause(&mut _self).into();
-                    output
-                },
-            );
+            .into();
+        output
+    }
+    fn elapsed(_self: Ref<bevy::time::Stopwatch>) {
+        let output: Val<bevy::utils::Duration> = bevy::time::Stopwatch::elapsed(&_self)
+            .into();
+        output
+    }
+    fn elapsed_secs(_self: Ref<bevy::time::Stopwatch>) {
+        let output: f32 = bevy::time::Stopwatch::elapsed_secs(&_self).into();
+        output
+    }
+    fn elapsed_secs_f64(_self: Ref<bevy::time::Stopwatch>) {
+        let output: f64 = bevy::time::Stopwatch::elapsed_secs_f64(&_self).into();
+        output
+    }
+    fn eq(_self: Ref<bevy::time::Stopwatch>, other: Ref<bevy::time::Stopwatch>) {
+        let output: bool = <bevy::time::Stopwatch as std::cmp::PartialEq<
+            bevy::time::Stopwatch,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn is_paused(_self: Ref<bevy::time::Stopwatch>) {
+        let output: bool = bevy::time::Stopwatch::is_paused(&_self).into();
+        output
+    }
+    fn new() {
+        let output: Val<bevy::time::Stopwatch> = bevy::time::Stopwatch::new().into();
+        output
+    }
+    fn pause(mut _self: Mut<bevy::time::Stopwatch>) {
+        let output: () = bevy::time::Stopwatch::pause(&mut _self).into();
+        output
+    }
+    fn reset(mut _self: Mut<bevy::time::Stopwatch>) {
+        let output: () = bevy::time::Stopwatch::reset(&mut _self).into();
+        output
+    }
+    fn set_elapsed(
+        mut _self: Mut<bevy::time::Stopwatch>,
+        time: Val<bevy::utils::Duration>,
+    ) {
+        let output: () = bevy::time::Stopwatch::set_elapsed(
+                &mut _self,
+                time.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn unpause(mut _self: Mut<bevy::time::Stopwatch>) {
+        let output: () = bevy::time::Stopwatch::unpause(&mut _self).into();
+        output
+    }
+}
+impl ::bevy::app::Plugin for BevyTimeScriptingPlugin {
+    fn build(&self, app: &mut ::bevy::prelude::App) {
+        let mut world = app.world_mut();
+        register_fixed(&mut world);
+        register_real(&mut world);
+        register_timer(&mut world);
+        register_timer_mode(&mut world);
+        register_virtual(&mut world);
+        register_stopwatch(&mut world);
     }
 }
diff --git a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_transform.rs b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_transform.rs
index c74b804a17..7513f0ae05 100644
--- a/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_transform.rs
+++ b/crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_transform.rs
@@ -9,804 +9,611 @@ use bevy_mod_scripting_core::bindings::{
         namespace::NamespaceBuilder,
     },
 };
+use bevy_mod_scripting_derive::script_bindings;
 use crate::*;
 pub struct BevyTransformScriptingPlugin;
+#[script_bindings(remote, name = "global_transform")]
+impl bevy::transform::components::GlobalTransform {
+    fn affine(_self: Ref<bevy::transform::components::GlobalTransform>) {
+        let output: Val<bevy::math::Affine3A> = bevy::transform::components::GlobalTransform::affine(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn back(_self: Ref<bevy::transform::components::GlobalTransform>) {
+        let output: Val<bevy::math::Dir3> = bevy::transform::components::GlobalTransform::back(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::transform::components::GlobalTransform>) {
+        let output: Val<bevy::transform::components::GlobalTransform> = <bevy::transform::components::GlobalTransform as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn compute_matrix(_self: Ref<bevy::transform::components::GlobalTransform>) {
+        let output: Val<bevy::math::Mat4> = bevy::transform::components::GlobalTransform::compute_matrix(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn compute_transform(_self: Ref<bevy::transform::components::GlobalTransform>) {
+        let output: Val<bevy::transform::components::Transform> = bevy::transform::components::GlobalTransform::compute_transform(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn down(_self: Ref<bevy::transform::components::GlobalTransform>) {
+        let output: Val<bevy::math::Dir3> = bevy::transform::components::GlobalTransform::down(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::transform::components::GlobalTransform>,
+        other: Ref<bevy::transform::components::GlobalTransform>,
+    ) {
+        let output: bool = <bevy::transform::components::GlobalTransform as std::cmp::PartialEq<
+            bevy::transform::components::GlobalTransform,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn forward(_self: Ref<bevy::transform::components::GlobalTransform>) {
+        let output: Val<bevy::math::Dir3> = bevy::transform::components::GlobalTransform::forward(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn from_isometry(iso: Val<bevy::math::Isometry3d>) {
+        let output: Val<bevy::transform::components::GlobalTransform> = bevy::transform::components::GlobalTransform::from_isometry(
+                iso.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_rotation(rotation: Val<bevy::math::Quat>) {
+        let output: Val<bevy::transform::components::GlobalTransform> = bevy::transform::components::GlobalTransform::from_rotation(
+                rotation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_scale(scale: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::transform::components::GlobalTransform> = bevy::transform::components::GlobalTransform::from_scale(
+                scale.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_translation(translation: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::transform::components::GlobalTransform> = bevy::transform::components::GlobalTransform::from_translation(
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_xyz(x: f32, y: f32, z: f32) {
+        let output: Val<bevy::transform::components::GlobalTransform> = bevy::transform::components::GlobalTransform::from_xyz(
+                x,
+                y,
+                z,
+            )
+            .into();
+        output
+    }
+    fn left(_self: Ref<bevy::transform::components::GlobalTransform>) {
+        let output: Val<bevy::math::Dir3> = bevy::transform::components::GlobalTransform::left(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn mul(
+        _self: Val<bevy::transform::components::GlobalTransform>,
+        value: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Vec3> = <bevy::transform::components::GlobalTransform as std::ops::Mul<
+            bevy::math::Vec3,
+        >>::mul(_self.into_inner(), value.into_inner())
+            .into();
+        output
+    }
+    fn mul(
+        _self: Val<bevy::transform::components::GlobalTransform>,
+        global_transform: Val<bevy::transform::components::GlobalTransform>,
+    ) {
+        let output: Val<bevy::transform::components::GlobalTransform> = <bevy::transform::components::GlobalTransform as std::ops::Mul<
+            bevy::transform::components::GlobalTransform,
+        >>::mul(_self.into_inner(), global_transform.into_inner())
+            .into();
+        output
+    }
+    fn mul(
+        _self: Val<bevy::transform::components::GlobalTransform>,
+        transform: Val<bevy::transform::components::Transform>,
+    ) {
+        let output: Val<bevy::transform::components::GlobalTransform> = <bevy::transform::components::GlobalTransform as std::ops::Mul<
+            bevy::transform::components::Transform,
+        >>::mul(_self.into_inner(), transform.into_inner())
+            .into();
+        output
+    }
+    fn mul_transform(
+        _self: Ref<bevy::transform::components::GlobalTransform>,
+        transform: Val<bevy::transform::components::Transform>,
+    ) {
+        let output: Val<bevy::transform::components::GlobalTransform> = bevy::transform::components::GlobalTransform::mul_transform(
+                &_self,
+                transform.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn radius_vec3a(
+        _self: Ref<bevy::transform::components::GlobalTransform>,
+        extents: Val<bevy::math::Vec3A>,
+    ) {
+        let output: f32 = bevy::transform::components::GlobalTransform::radius_vec3a(
+                &_self,
+                extents.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn reparented_to(
+        _self: Ref<bevy::transform::components::GlobalTransform>,
+        parent: Ref<bevy::transform::components::GlobalTransform>,
+    ) {
+        let output: Val<bevy::transform::components::Transform> = bevy::transform::components::GlobalTransform::reparented_to(
+                &_self,
+                &parent,
+            )
+            .into();
+        output
+    }
+    fn right(_self: Ref<bevy::transform::components::GlobalTransform>) {
+        let output: Val<bevy::math::Dir3> = bevy::transform::components::GlobalTransform::right(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn rotation(_self: Ref<bevy::transform::components::GlobalTransform>) {
+        let output: Val<bevy::math::Quat> = bevy::transform::components::GlobalTransform::rotation(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn scale(_self: Ref<bevy::transform::components::GlobalTransform>) {
+        let output: Val<bevy::math::Vec3> = bevy::transform::components::GlobalTransform::scale(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn to_isometry(_self: Ref<bevy::transform::components::GlobalTransform>) {
+        let output: Val<bevy::math::Isometry3d> = bevy::transform::components::GlobalTransform::to_isometry(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn transform_point(
+        _self: Ref<bevy::transform::components::GlobalTransform>,
+        point: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Vec3> = bevy::transform::components::GlobalTransform::transform_point(
+                &_self,
+                point.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn translation(_self: Ref<bevy::transform::components::GlobalTransform>) {
+        let output: Val<bevy::math::Vec3> = bevy::transform::components::GlobalTransform::translation(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn translation_vec3a(_self: Ref<bevy::transform::components::GlobalTransform>) {
+        let output: Val<bevy::math::Vec3A> = bevy::transform::components::GlobalTransform::translation_vec3a(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn up(_self: Ref<bevy::transform::components::GlobalTransform>) {
+        let output: Val<bevy::math::Dir3> = bevy::transform::components::GlobalTransform::up(
+                &_self,
+            )
+            .into();
+        output
+    }
+}
+#[script_bindings(remote, name = "transform")]
+impl bevy::transform::components::Transform {
+    fn back(_self: Ref<bevy::transform::components::Transform>) {
+        let output: Val<bevy::math::Dir3> = bevy::transform::components::Transform::back(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn clone(_self: Ref<bevy::transform::components::Transform>) {
+        let output: Val<bevy::transform::components::Transform> = <bevy::transform::components::Transform as std::clone::Clone>::clone(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn compute_affine(_self: Ref<bevy::transform::components::Transform>) {
+        let output: Val<bevy::math::Affine3A> = bevy::transform::components::Transform::compute_affine(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn compute_matrix(_self: Ref<bevy::transform::components::Transform>) {
+        let output: Val<bevy::math::Mat4> = bevy::transform::components::Transform::compute_matrix(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn down(_self: Ref<bevy::transform::components::Transform>) {
+        let output: Val<bevy::math::Dir3> = bevy::transform::components::Transform::down(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn eq(
+        _self: Ref<bevy::transform::components::Transform>,
+        other: Ref<bevy::transform::components::Transform>,
+    ) {
+        let output: bool = <bevy::transform::components::Transform as std::cmp::PartialEq<
+            bevy::transform::components::Transform,
+        >>::eq(&_self, &other)
+            .into();
+        output
+    }
+    fn forward(_self: Ref<bevy::transform::components::Transform>) {
+        let output: Val<bevy::math::Dir3> = bevy::transform::components::Transform::forward(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn from_isometry(iso: Val<bevy::math::Isometry3d>) {
+        let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::from_isometry(
+                iso.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_matrix(world_from_local: Val<bevy::math::Mat4>) {
+        let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::from_matrix(
+                world_from_local.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_rotation(rotation: Val<bevy::math::Quat>) {
+        let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::from_rotation(
+                rotation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_scale(scale: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::from_scale(
+                scale.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_translation(translation: Val<bevy::math::Vec3>) {
+        let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::from_translation(
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn from_xyz(x: f32, y: f32, z: f32) {
+        let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::from_xyz(
+                x,
+                y,
+                z,
+            )
+            .into();
+        output
+    }
+    fn is_finite(_self: Ref<bevy::transform::components::Transform>) {
+        let output: bool = bevy::transform::components::Transform::is_finite(&_self)
+            .into();
+        output
+    }
+    fn left(_self: Ref<bevy::transform::components::Transform>) {
+        let output: Val<bevy::math::Dir3> = bevy::transform::components::Transform::left(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn local_x(_self: Ref<bevy::transform::components::Transform>) {
+        let output: Val<bevy::math::Dir3> = bevy::transform::components::Transform::local_x(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn local_y(_self: Ref<bevy::transform::components::Transform>) {
+        let output: Val<bevy::math::Dir3> = bevy::transform::components::Transform::local_y(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn local_z(_self: Ref<bevy::transform::components::Transform>) {
+        let output: Val<bevy::math::Dir3> = bevy::transform::components::Transform::local_z(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn mul(
+        _self: Val<bevy::transform::components::Transform>,
+        value: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Vec3> = <bevy::transform::components::Transform as std::ops::Mul<
+            bevy::math::Vec3,
+        >>::mul(_self.into_inner(), value.into_inner())
+            .into();
+        output
+    }
+    fn mul(
+        _self: Val<bevy::transform::components::Transform>,
+        global_transform: Val<bevy::transform::components::GlobalTransform>,
+    ) {
+        let output: Val<bevy::transform::components::GlobalTransform> = <bevy::transform::components::Transform as std::ops::Mul<
+            bevy::transform::components::GlobalTransform,
+        >>::mul(_self.into_inner(), global_transform.into_inner())
+            .into();
+        output
+    }
+    fn mul(
+        _self: Val<bevy::transform::components::Transform>,
+        transform: Val<bevy::transform::components::Transform>,
+    ) {
+        let output: Val<bevy::transform::components::Transform> = <bevy::transform::components::Transform as std::ops::Mul<
+            bevy::transform::components::Transform,
+        >>::mul(_self.into_inner(), transform.into_inner())
+            .into();
+        output
+    }
+    fn mul_transform(
+        _self: Ref<bevy::transform::components::Transform>,
+        transform: Val<bevy::transform::components::Transform>,
+    ) {
+        let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::mul_transform(
+                &_self,
+                transform.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn right(_self: Ref<bevy::transform::components::Transform>) {
+        let output: Val<bevy::math::Dir3> = bevy::transform::components::Transform::right(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn rotate(
+        mut _self: Mut<bevy::transform::components::Transform>,
+        rotation: Val<bevy::math::Quat>,
+    ) {
+        let output: () = bevy::transform::components::Transform::rotate(
+                &mut _self,
+                rotation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rotate_around(
+        mut _self: Mut<bevy::transform::components::Transform>,
+        point: Val<bevy::math::Vec3>,
+        rotation: Val<bevy::math::Quat>,
+    ) {
+        let output: () = bevy::transform::components::Transform::rotate_around(
+                &mut _self,
+                point.into_inner(),
+                rotation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rotate_axis(
+        mut _self: Mut<bevy::transform::components::Transform>,
+        axis: Val<bevy::math::Dir3>,
+        angle: f32,
+    ) {
+        let output: () = bevy::transform::components::Transform::rotate_axis(
+                &mut _self,
+                axis.into_inner(),
+                angle,
+            )
+            .into();
+        output
+    }
+    fn rotate_local(
+        mut _self: Mut<bevy::transform::components::Transform>,
+        rotation: Val<bevy::math::Quat>,
+    ) {
+        let output: () = bevy::transform::components::Transform::rotate_local(
+                &mut _self,
+                rotation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn rotate_local_axis(
+        mut _self: Mut<bevy::transform::components::Transform>,
+        axis: Val<bevy::math::Dir3>,
+        angle: f32,
+    ) {
+        let output: () = bevy::transform::components::Transform::rotate_local_axis(
+                &mut _self,
+                axis.into_inner(),
+                angle,
+            )
+            .into();
+        output
+    }
+    fn rotate_local_x(
+        mut _self: Mut<bevy::transform::components::Transform>,
+        angle: f32,
+    ) {
+        let output: () = bevy::transform::components::Transform::rotate_local_x(
+                &mut _self,
+                angle,
+            )
+            .into();
+        output
+    }
+    fn rotate_local_y(
+        mut _self: Mut<bevy::transform::components::Transform>,
+        angle: f32,
+    ) {
+        let output: () = bevy::transform::components::Transform::rotate_local_y(
+                &mut _self,
+                angle,
+            )
+            .into();
+        output
+    }
+    fn rotate_local_z(
+        mut _self: Mut<bevy::transform::components::Transform>,
+        angle: f32,
+    ) {
+        let output: () = bevy::transform::components::Transform::rotate_local_z(
+                &mut _self,
+                angle,
+            )
+            .into();
+        output
+    }
+    fn rotate_x(mut _self: Mut<bevy::transform::components::Transform>, angle: f32) {
+        let output: () = bevy::transform::components::Transform::rotate_x(
+                &mut _self,
+                angle,
+            )
+            .into();
+        output
+    }
+    fn rotate_y(mut _self: Mut<bevy::transform::components::Transform>, angle: f32) {
+        let output: () = bevy::transform::components::Transform::rotate_y(
+                &mut _self,
+                angle,
+            )
+            .into();
+        output
+    }
+    fn rotate_z(mut _self: Mut<bevy::transform::components::Transform>, angle: f32) {
+        let output: () = bevy::transform::components::Transform::rotate_z(
+                &mut _self,
+                angle,
+            )
+            .into();
+        output
+    }
+    fn to_isometry(_self: Ref<bevy::transform::components::Transform>) {
+        let output: Val<bevy::math::Isometry3d> = bevy::transform::components::Transform::to_isometry(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn transform_point(
+        _self: Ref<bevy::transform::components::Transform>,
+        point: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::math::Vec3> = bevy::transform::components::Transform::transform_point(
+                &_self,
+                point.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn translate_around(
+        mut _self: Mut<bevy::transform::components::Transform>,
+        point: Val<bevy::math::Vec3>,
+        rotation: Val<bevy::math::Quat>,
+    ) {
+        let output: () = bevy::transform::components::Transform::translate_around(
+                &mut _self,
+                point.into_inner(),
+                rotation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn up(_self: Ref<bevy::transform::components::Transform>) {
+        let output: Val<bevy::math::Dir3> = bevy::transform::components::Transform::up(
+                &_self,
+            )
+            .into();
+        output
+    }
+    fn with_rotation(
+        _self: Val<bevy::transform::components::Transform>,
+        rotation: Val<bevy::math::Quat>,
+    ) {
+        let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::with_rotation(
+                _self.into_inner(),
+                rotation.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn with_scale(
+        _self: Val<bevy::transform::components::Transform>,
+        scale: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::with_scale(
+                _self.into_inner(),
+                scale.into_inner(),
+            )
+            .into();
+        output
+    }
+    fn with_translation(
+        _self: Val<bevy::transform::components::Transform>,
+        translation: Val<bevy::math::Vec3>,
+    ) {
+        let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::with_translation(
+                _self.into_inner(),
+                translation.into_inner(),
+            )
+            .into();
+        output
+    }
+}
 impl ::bevy::app::Plugin for BevyTransformScriptingPlugin {
     fn build(&self, app: &mut ::bevy::prelude::App) {
         let mut world = app.world_mut();
-        NamespaceBuilder::<::bevy::transform::components::GlobalTransform>::new(world)
-            .register(
-                "affine",
-                |_self: Ref<bevy::transform::components::GlobalTransform>| {
-                    let output: Val<bevy::math::Affine3A> = bevy::transform::components::GlobalTransform::affine(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "back",
-                |_self: Ref<bevy::transform::components::GlobalTransform>| {
-                    let output: Val<bevy::math::Dir3> = bevy::transform::components::GlobalTransform::back(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::transform::components::GlobalTransform>| {
-                    let output: Val<bevy::transform::components::GlobalTransform> = <bevy::transform::components::GlobalTransform as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "compute_matrix",
-                |_self: Ref<bevy::transform::components::GlobalTransform>| {
-                    let output: Val<bevy::math::Mat4> = bevy::transform::components::GlobalTransform::compute_matrix(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "compute_transform",
-                |_self: Ref<bevy::transform::components::GlobalTransform>| {
-                    let output: Val<bevy::transform::components::Transform> = bevy::transform::components::GlobalTransform::compute_transform(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "down",
-                |_self: Ref<bevy::transform::components::GlobalTransform>| {
-                    let output: Val<bevy::math::Dir3> = bevy::transform::components::GlobalTransform::down(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::transform::components::GlobalTransform>,
-                    other: Ref<bevy::transform::components::GlobalTransform>|
-                {
-                    let output: bool = <bevy::transform::components::GlobalTransform as std::cmp::PartialEq<
-                        bevy::transform::components::GlobalTransform,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "forward",
-                |_self: Ref<bevy::transform::components::GlobalTransform>| {
-                    let output: Val<bevy::math::Dir3> = bevy::transform::components::GlobalTransform::forward(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_isometry",
-                |iso: Val<bevy::math::Isometry3d>| {
-                    let output: Val<bevy::transform::components::GlobalTransform> = bevy::transform::components::GlobalTransform::from_isometry(
-                            iso.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation",
-                |rotation: Val<bevy::math::Quat>| {
-                    let output: Val<bevy::transform::components::GlobalTransform> = bevy::transform::components::GlobalTransform::from_rotation(
-                            rotation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale",
-                |scale: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::transform::components::GlobalTransform> = bevy::transform::components::GlobalTransform::from_scale(
-                            scale.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_translation",
-                |translation: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::transform::components::GlobalTransform> = bevy::transform::components::GlobalTransform::from_translation(
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_xyz",
-                |x: f32, y: f32, z: f32| {
-                    let output: Val<bevy::transform::components::GlobalTransform> = bevy::transform::components::GlobalTransform::from_xyz(
-                            x,
-                            y,
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "left",
-                |_self: Ref<bevy::transform::components::GlobalTransform>| {
-                    let output: Val<bevy::math::Dir3> = bevy::transform::components::GlobalTransform::left(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |
-                    _self: Val<bevy::transform::components::GlobalTransform>,
-                    value: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::math::Vec3> = <bevy::transform::components::GlobalTransform as std::ops::Mul<
-                        bevy::math::Vec3,
-                    >>::mul(_self.into_inner(), value.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |
-                    _self: Val<bevy::transform::components::GlobalTransform>,
-                    global_transform: Val<bevy::transform::components::GlobalTransform>|
-                {
-                    let output: Val<bevy::transform::components::GlobalTransform> = <bevy::transform::components::GlobalTransform as std::ops::Mul<
-                        bevy::transform::components::GlobalTransform,
-                    >>::mul(_self.into_inner(), global_transform.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |
-                    _self: Val<bevy::transform::components::GlobalTransform>,
-                    transform: Val<bevy::transform::components::Transform>|
-                {
-                    let output: Val<bevy::transform::components::GlobalTransform> = <bevy::transform::components::GlobalTransform as std::ops::Mul<
-                        bevy::transform::components::Transform,
-                    >>::mul(_self.into_inner(), transform.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_transform",
-                |
-                    _self: Ref<bevy::transform::components::GlobalTransform>,
-                    transform: Val<bevy::transform::components::Transform>|
-                {
-                    let output: Val<bevy::transform::components::GlobalTransform> = bevy::transform::components::GlobalTransform::mul_transform(
-                            &_self,
-                            transform.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "radius_vec3a",
-                |
-                    _self: Ref<bevy::transform::components::GlobalTransform>,
-                    extents: Val<bevy::math::Vec3A>|
-                {
-                    let output: f32 = bevy::transform::components::GlobalTransform::radius_vec3a(
-                            &_self,
-                            extents.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "reparented_to",
-                |
-                    _self: Ref<bevy::transform::components::GlobalTransform>,
-                    parent: Ref<bevy::transform::components::GlobalTransform>|
-                {
-                    let output: Val<bevy::transform::components::Transform> = bevy::transform::components::GlobalTransform::reparented_to(
-                            &_self,
-                            &parent,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "right",
-                |_self: Ref<bevy::transform::components::GlobalTransform>| {
-                    let output: Val<bevy::math::Dir3> = bevy::transform::components::GlobalTransform::right(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotation",
-                |_self: Ref<bevy::transform::components::GlobalTransform>| {
-                    let output: Val<bevy::math::Quat> = bevy::transform::components::GlobalTransform::rotation(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "scale",
-                |_self: Ref<bevy::transform::components::GlobalTransform>| {
-                    let output: Val<bevy::math::Vec3> = bevy::transform::components::GlobalTransform::scale(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_isometry",
-                |_self: Ref<bevy::transform::components::GlobalTransform>| {
-                    let output: Val<bevy::math::Isometry3d> = bevy::transform::components::GlobalTransform::to_isometry(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_point",
-                |
-                    _self: Ref<bevy::transform::components::GlobalTransform>,
-                    point: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::math::Vec3> = bevy::transform::components::GlobalTransform::transform_point(
-                            &_self,
-                            point.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "translation",
-                |_self: Ref<bevy::transform::components::GlobalTransform>| {
-                    let output: Val<bevy::math::Vec3> = bevy::transform::components::GlobalTransform::translation(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "translation_vec3a",
-                |_self: Ref<bevy::transform::components::GlobalTransform>| {
-                    let output: Val<bevy::math::Vec3A> = bevy::transform::components::GlobalTransform::translation_vec3a(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "up",
-                |_self: Ref<bevy::transform::components::GlobalTransform>| {
-                    let output: Val<bevy::math::Dir3> = bevy::transform::components::GlobalTransform::up(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            );
-        NamespaceBuilder::<::bevy::transform::components::Transform>::new(world)
-            .register(
-                "back",
-                |_self: Ref<bevy::transform::components::Transform>| {
-                    let output: Val<bevy::math::Dir3> = bevy::transform::components::Transform::back(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "clone",
-                |_self: Ref<bevy::transform::components::Transform>| {
-                    let output: Val<bevy::transform::components::Transform> = <bevy::transform::components::Transform as std::clone::Clone>::clone(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "compute_affine",
-                |_self: Ref<bevy::transform::components::Transform>| {
-                    let output: Val<bevy::math::Affine3A> = bevy::transform::components::Transform::compute_affine(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "compute_matrix",
-                |_self: Ref<bevy::transform::components::Transform>| {
-                    let output: Val<bevy::math::Mat4> = bevy::transform::components::Transform::compute_matrix(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "down",
-                |_self: Ref<bevy::transform::components::Transform>| {
-                    let output: Val<bevy::math::Dir3> = bevy::transform::components::Transform::down(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "eq",
-                |
-                    _self: Ref<bevy::transform::components::Transform>,
-                    other: Ref<bevy::transform::components::Transform>|
-                {
-                    let output: bool = <bevy::transform::components::Transform as std::cmp::PartialEq<
-                        bevy::transform::components::Transform,
-                    >>::eq(&_self, &other)
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "forward",
-                |_self: Ref<bevy::transform::components::Transform>| {
-                    let output: Val<bevy::math::Dir3> = bevy::transform::components::Transform::forward(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_isometry",
-                |iso: Val<bevy::math::Isometry3d>| {
-                    let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::from_isometry(
-                            iso.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_matrix",
-                |world_from_local: Val<bevy::math::Mat4>| {
-                    let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::from_matrix(
-                            world_from_local.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_rotation",
-                |rotation: Val<bevy::math::Quat>| {
-                    let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::from_rotation(
-                            rotation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_scale",
-                |scale: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::from_scale(
-                            scale.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_translation",
-                |translation: Val<bevy::math::Vec3>| {
-                    let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::from_translation(
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "from_xyz",
-                |x: f32, y: f32, z: f32| {
-                    let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::from_xyz(
-                            x,
-                            y,
-                            z,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "is_finite",
-                |_self: Ref<bevy::transform::components::Transform>| {
-                    let output: bool = bevy::transform::components::Transform::is_finite(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "left",
-                |_self: Ref<bevy::transform::components::Transform>| {
-                    let output: Val<bevy::math::Dir3> = bevy::transform::components::Transform::left(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "local_x",
-                |_self: Ref<bevy::transform::components::Transform>| {
-                    let output: Val<bevy::math::Dir3> = bevy::transform::components::Transform::local_x(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "local_y",
-                |_self: Ref<bevy::transform::components::Transform>| {
-                    let output: Val<bevy::math::Dir3> = bevy::transform::components::Transform::local_y(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "local_z",
-                |_self: Ref<bevy::transform::components::Transform>| {
-                    let output: Val<bevy::math::Dir3> = bevy::transform::components::Transform::local_z(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |
-                    _self: Val<bevy::transform::components::Transform>,
-                    value: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::math::Vec3> = <bevy::transform::components::Transform as std::ops::Mul<
-                        bevy::math::Vec3,
-                    >>::mul(_self.into_inner(), value.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |
-                    _self: Val<bevy::transform::components::Transform>,
-                    global_transform: Val<bevy::transform::components::GlobalTransform>|
-                {
-                    let output: Val<bevy::transform::components::GlobalTransform> = <bevy::transform::components::Transform as std::ops::Mul<
-                        bevy::transform::components::GlobalTransform,
-                    >>::mul(_self.into_inner(), global_transform.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul",
-                |
-                    _self: Val<bevy::transform::components::Transform>,
-                    transform: Val<bevy::transform::components::Transform>|
-                {
-                    let output: Val<bevy::transform::components::Transform> = <bevy::transform::components::Transform as std::ops::Mul<
-                        bevy::transform::components::Transform,
-                    >>::mul(_self.into_inner(), transform.into_inner())
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "mul_transform",
-                |
-                    _self: Ref<bevy::transform::components::Transform>,
-                    transform: Val<bevy::transform::components::Transform>|
-                {
-                    let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::mul_transform(
-                            &_self,
-                            transform.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "right",
-                |_self: Ref<bevy::transform::components::Transform>| {
-                    let output: Val<bevy::math::Dir3> = bevy::transform::components::Transform::right(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotate",
-                |
-                    mut _self: Mut<bevy::transform::components::Transform>,
-                    rotation: Val<bevy::math::Quat>|
-                {
-                    let output: () = bevy::transform::components::Transform::rotate(
-                            &mut _self,
-                            rotation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotate_around",
-                |
-                    mut _self: Mut<bevy::transform::components::Transform>,
-                    point: Val<bevy::math::Vec3>,
-                    rotation: Val<bevy::math::Quat>|
-                {
-                    let output: () = bevy::transform::components::Transform::rotate_around(
-                            &mut _self,
-                            point.into_inner(),
-                            rotation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotate_axis",
-                |
-                    mut _self: Mut<bevy::transform::components::Transform>,
-                    axis: Val<bevy::math::Dir3>,
-                    angle: f32|
-                {
-                    let output: () = bevy::transform::components::Transform::rotate_axis(
-                            &mut _self,
-                            axis.into_inner(),
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotate_local",
-                |
-                    mut _self: Mut<bevy::transform::components::Transform>,
-                    rotation: Val<bevy::math::Quat>|
-                {
-                    let output: () = bevy::transform::components::Transform::rotate_local(
-                            &mut _self,
-                            rotation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotate_local_axis",
-                |
-                    mut _self: Mut<bevy::transform::components::Transform>,
-                    axis: Val<bevy::math::Dir3>,
-                    angle: f32|
-                {
-                    let output: () = bevy::transform::components::Transform::rotate_local_axis(
-                            &mut _self,
-                            axis.into_inner(),
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotate_local_x",
-                |mut _self: Mut<bevy::transform::components::Transform>, angle: f32| {
-                    let output: () = bevy::transform::components::Transform::rotate_local_x(
-                            &mut _self,
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotate_local_y",
-                |mut _self: Mut<bevy::transform::components::Transform>, angle: f32| {
-                    let output: () = bevy::transform::components::Transform::rotate_local_y(
-                            &mut _self,
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotate_local_z",
-                |mut _self: Mut<bevy::transform::components::Transform>, angle: f32| {
-                    let output: () = bevy::transform::components::Transform::rotate_local_z(
-                            &mut _self,
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotate_x",
-                |mut _self: Mut<bevy::transform::components::Transform>, angle: f32| {
-                    let output: () = bevy::transform::components::Transform::rotate_x(
-                            &mut _self,
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotate_y",
-                |mut _self: Mut<bevy::transform::components::Transform>, angle: f32| {
-                    let output: () = bevy::transform::components::Transform::rotate_y(
-                            &mut _self,
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "rotate_z",
-                |mut _self: Mut<bevy::transform::components::Transform>, angle: f32| {
-                    let output: () = bevy::transform::components::Transform::rotate_z(
-                            &mut _self,
-                            angle,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "to_isometry",
-                |_self: Ref<bevy::transform::components::Transform>| {
-                    let output: Val<bevy::math::Isometry3d> = bevy::transform::components::Transform::to_isometry(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "transform_point",
-                |
-                    _self: Ref<bevy::transform::components::Transform>,
-                    point: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::math::Vec3> = bevy::transform::components::Transform::transform_point(
-                            &_self,
-                            point.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "translate_around",
-                |
-                    mut _self: Mut<bevy::transform::components::Transform>,
-                    point: Val<bevy::math::Vec3>,
-                    rotation: Val<bevy::math::Quat>|
-                {
-                    let output: () = bevy::transform::components::Transform::translate_around(
-                            &mut _self,
-                            point.into_inner(),
-                            rotation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "up",
-                |_self: Ref<bevy::transform::components::Transform>| {
-                    let output: Val<bevy::math::Dir3> = bevy::transform::components::Transform::up(
-                            &_self,
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_rotation",
-                |
-                    _self: Val<bevy::transform::components::Transform>,
-                    rotation: Val<bevy::math::Quat>|
-                {
-                    let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::with_rotation(
-                            _self.into_inner(),
-                            rotation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_scale",
-                |
-                    _self: Val<bevy::transform::components::Transform>,
-                    scale: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::with_scale(
-                            _self.into_inner(),
-                            scale.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            )
-            .register(
-                "with_translation",
-                |
-                    _self: Val<bevy::transform::components::Transform>,
-                    translation: Val<bevy::math::Vec3>|
-                {
-                    let output: Val<bevy::transform::components::Transform> = bevy::transform::components::Transform::with_translation(
-                            _self.into_inner(),
-                            translation.into_inner(),
-                        )
-                        .into();
-                    output
-                },
-            );
+        register_global_transform(&mut world);
+        register_transform(&mut world);
     }
 }