diff --git a/benches/benches/bevy_reflect/list.rs b/benches/benches/bevy_reflect/list.rs
index fcbe59accdbc7..cedc03364cf92 100644
--- a/benches/benches/bevy_reflect/list.rs
+++ b/benches/benches/bevy_reflect/list.rs
@@ -1,7 +1,7 @@
 use core::{hint::black_box, iter, time::Duration};
 
 use benches::bench;
-use bevy_reflect::{DynamicList, List};
+use bevy_reflect::list::{DynamicList, List};
 use criterion::{
     criterion_group, measurement::Measurement, AxisScale, BatchSize, BenchmarkGroup, BenchmarkId,
     Criterion, PlotConfiguration, Throughput,
diff --git a/benches/benches/bevy_reflect/map.rs b/benches/benches/bevy_reflect/map.rs
index a70f89e12b7f1..3f4a796868b87 100644
--- a/benches/benches/bevy_reflect/map.rs
+++ b/benches/benches/bevy_reflect/map.rs
@@ -2,7 +2,7 @@ use core::{fmt::Write, hint::black_box, iter, time::Duration};
 
 use benches::bench;
 use bevy_platform::collections::HashMap;
-use bevy_reflect::{DynamicMap, Map};
+use bevy_reflect::map::{DynamicMap, Map};
 use criterion::{
     criterion_group, measurement::Measurement, AxisScale, BatchSize, BenchmarkGroup, BenchmarkId,
     Criterion, PlotConfiguration, Throughput,
diff --git a/benches/benches/bevy_reflect/struct.rs b/benches/benches/bevy_reflect/struct.rs
index 52d539f64dd2a..c368cc1168dea 100644
--- a/benches/benches/bevy_reflect/struct.rs
+++ b/benches/benches/bevy_reflect/struct.rs
@@ -1,7 +1,10 @@
 use core::{hint::black_box, time::Duration};
 
 use benches::bench;
-use bevy_reflect::{DynamicStruct, GetField, PartialReflect, Reflect, Struct};
+use bevy_reflect::{
+    structs::{DynamicStruct, GetField, Struct},
+    PartialReflect, Reflect,
+};
 use criterion::{
     criterion_group, measurement::Measurement, AxisScale, BatchSize, BenchmarkGroup, BenchmarkId,
     Criterion, PlotConfiguration, Throughput,
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 146ce09c36f9d..1db697dacf759 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1522,7 +1522,7 @@ impl<'a> Iterator for TriggeredEventsIter<'a> {
 #[cfg(test)]
 mod tests {
     use crate as bevy_animation;
-    use bevy_reflect::{DynamicMap, Map};
+    use bevy_reflect::map::{DynamicMap, Map};
 
     use super::*;
 
diff --git a/crates/bevy_reflect/compile_fail/tests/reflect_derive/generics_fail.rs b/crates/bevy_reflect/compile_fail/tests/reflect_derive/generics_fail.rs
index 6f90097828b64..497ffe29257cf 100644
--- a/crates/bevy_reflect/compile_fail/tests/reflect_derive/generics_fail.rs
+++ b/crates/bevy_reflect/compile_fail/tests/reflect_derive/generics_fail.rs
@@ -1,4 +1,7 @@
-use bevy_reflect::{GetField, Reflect, Struct, TypePath};
+use bevy_reflect::{
+    structs::{GetField, Struct},
+    Reflect, TypePath,
+};
 
 #[derive(Reflect)]
 #[reflect(from_reflect = false)]
diff --git a/crates/bevy_reflect/compile_fail/tests/reflect_derive/generics_fail.stderr b/crates/bevy_reflect/compile_fail/tests/reflect_derive/generics_fail.stderr
index 8c4890827de6c..ec14baf4788b2 100644
--- a/crates/bevy_reflect/compile_fail/tests/reflect_derive/generics_fail.stderr
+++ b/crates/bevy_reflect/compile_fail/tests/reflect_derive/generics_fail.stderr
@@ -1,7 +1,7 @@
 error[E0277]: `NoReflect` can not be reflected
    --> tests/reflect_derive/generics_fail.rs:18:21
     |
-18  |     foo.get_field::<NoReflect>("a").unwrap();
+22  |     foo.get_field::<NoReflect>("a").unwrap();
     |         ---------   ^^^^^^^^^ the trait `Reflect` is not implemented for `NoReflect`
     |         |
     |         required by a bound introduced by this call
@@ -26,7 +26,7 @@ note: required by a bound in `bevy_reflect::GetField::get_field`
 error[E0277]: `NoReflect` does not provide type registration information
   --> tests/reflect_derive/generics_fail.rs:14:36
    |
-14 |     let mut foo: Box<dyn Struct> = Box::new(Foo::<NoReflect> { a: NoReflect(42.0) });
+17 |     let mut foo: Box<dyn Struct> = Box::new(Foo::<NoReflect> { a: NoReflect(42.0) });
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Invalid Type
    |
    = help: the trait `GetTypeRegistration` is not implemented for `NoReflect`, which is required by `Foo<NoReflect>: bevy_reflect::Struct`
@@ -45,10 +45,10 @@ error[E0277]: `NoReflect` does not provide type registration information
 note: required for `Foo<NoReflect>` to implement `bevy_reflect::Struct`
   --> tests/reflect_derive/generics_fail.rs:3:10
    |
-3  | #[derive(Reflect)]
+6  | #[derive(Reflect)]
    |          ^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
-4  | #[reflect(from_reflect = false)]
-5  | struct Foo<T> {
+7  | #[reflect(from_reflect = false)]
+8  | struct Foo<T> {
    |        ^^^^^^
    = note: required for the cast from `Box<Foo<NoReflect>>` to `Box<(dyn bevy_reflect::Struct + 'static)>`
    = note: this error originates in the derive macro `Reflect` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/crates/bevy_reflect/compile_fail/tests/reflect_derive/generics_structs_pass.rs b/crates/bevy_reflect/compile_fail/tests/reflect_derive/generics_structs_pass.rs
index 742dd1b883666..887a8fb9cc964 100644
--- a/crates/bevy_reflect/compile_fail/tests/reflect_derive/generics_structs_pass.rs
+++ b/crates/bevy_reflect/compile_fail/tests/reflect_derive/generics_structs_pass.rs
@@ -1,5 +1,5 @@
 //@check-pass
-use bevy_reflect::{GetField, Reflect};
+use bevy_reflect::{structs::GetField, Reflect};
 
 #[derive(Reflect)]
 #[reflect(from_reflect = false)]
diff --git a/crates/bevy_reflect/derive/src/derive_data.rs b/crates/bevy_reflect/derive/src/derive_data.rs
index 1b51754c9b632..cc4581ffda473 100644
--- a/crates/bevy_reflect/derive/src/derive_data.rs
+++ b/crates/bevy_reflect/derive/src/derive_data.rs
@@ -648,15 +648,15 @@ impl<'a> ReflectStruct<'a> {
     pub fn to_info_tokens(&self, is_tuple: bool) -> proc_macro2::TokenStream {
         let bevy_reflect_path = self.meta().bevy_reflect_path();
 
-        let (info_variant, info_struct) = if is_tuple {
+        let (info_variant, info_struct): (_, Path) = if is_tuple {
             (
                 Ident::new("TupleStruct", Span::call_site()),
-                Ident::new("TupleStructInfo", Span::call_site()),
+                parse_str("tuple_struct::TupleStructInfo").expect("should be a valid path"),
             )
         } else {
             (
                 Ident::new("Struct", Span::call_site()),
-                Ident::new("StructInfo", Span::call_site()),
+                parse_str("structs::StructInfo").expect("should be a valid path"),
             )
         };
 
@@ -888,7 +888,7 @@ impl<'a> ReflectEnum<'a> {
             .map(|variant| variant.to_info_tokens(bevy_reflect_path));
 
         let mut info = quote! {
-            #bevy_reflect_path::EnumInfo::new::<Self>(&[
+            #bevy_reflect_path::enums::EnumInfo::new::<Self>(&[
                 #(#variants),*
             ])
         };
@@ -1015,7 +1015,7 @@ impl<'a> EnumVariant<'a> {
         };
 
         let mut info = quote! {
-            #bevy_reflect_path::#info_struct::new(#args)
+            #bevy_reflect_path::enums::#info_struct::new(#args)
         };
 
         let custom_attributes = &self.attrs.custom_attributes;
@@ -1037,7 +1037,7 @@ impl<'a> EnumVariant<'a> {
         }
 
         quote! {
-            #bevy_reflect_path::VariantInfo::#info_variant(#info)
+            #bevy_reflect_path::enums::VariantInfo::#info_variant(#info)
         }
     }
 }
diff --git a/crates/bevy_reflect/derive/src/from_reflect.rs b/crates/bevy_reflect/derive/src/from_reflect.rs
index 970782d5395ea..e046705f5bdb2 100644
--- a/crates/bevy_reflect/derive/src/from_reflect.rs
+++ b/crates/bevy_reflect/derive/src/from_reflect.rs
@@ -10,7 +10,7 @@ use bevy_macro_utils::as_member;
 use bevy_macro_utils::fq_std::{FQClone, FQDefault, FQOption};
 use proc_macro2::Span;
 use quote::{quote, ToTokens};
-use syn::{Field, Ident, Lit, LitInt, LitStr, Member};
+use syn::{parse_str, Field, Ident, Lit, LitInt, LitStr, Member, Path};
 
 /// Implements `FromReflect` for the given struct
 pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> proc_macro2::TokenStream {
@@ -93,7 +93,7 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
                 if let #bevy_reflect_path::ReflectRef::Enum(#ref_value) =
                     #bevy_reflect_path::PartialReflect::reflect_ref(#ref_value)
                 {
-                    match #bevy_reflect_path::Enum::variant_name(#ref_value) {
+                    match #bevy_reflect_path::enums::Enum::variant_name(#ref_value) {
                         #match_branches
                         name => panic!("variant with name `{}` does not exist on enum `{}`", name, <Self as #bevy_reflect_path::TypePath>::type_path()),
                     }
@@ -126,14 +126,20 @@ fn impl_struct_internal(
     let bevy_reflect_path = reflect_struct.meta().bevy_reflect_path();
 
     let ref_struct = Ident::new("__ref_struct", Span::call_site());
-    let ref_struct_type = if is_tuple {
-        Ident::new("TupleStruct", Span::call_site())
+    let (ref_struct_type, ref_struct_path) = if is_tuple {
+        (
+            Ident::new("TupleStruct", Span::call_site()),
+            parse_str("tuple_struct::TupleStruct").expect("should be a valid path"),
+        )
     } else {
-        Ident::new("Struct", Span::call_site())
+        (
+            Ident::new("Struct", Span::call_site()),
+            parse_str("structs::Struct").expect("should be a valid path"),
+        )
     };
 
     let MemberValuePair(active_members, active_values) =
-        get_active_fields(reflect_struct, &ref_struct, &ref_struct_type, is_tuple);
+        get_active_fields(reflect_struct, &ref_struct, &ref_struct_path, is_tuple);
 
     let is_defaultable = reflect_struct.meta().attrs().contains(REFLECT_DEFAULT);
 
@@ -236,7 +242,7 @@ fn get_ignored_fields(reflect_struct: &ReflectStruct) -> MemberValuePair {
 fn get_active_fields(
     reflect_struct: &ReflectStruct,
     dyn_struct_name: &Ident,
-    struct_type: &Ident,
+    struct_type: &Path,
     is_tuple: bool,
 ) -> MemberValuePair {
     let bevy_reflect_path = reflect_struct.meta().bevy_reflect_path();
diff --git a/crates/bevy_reflect/derive/src/impls/enums.rs b/crates/bevy_reflect/derive/src/impls/enums.rs
index 68f98e2617d26..efdd8444c1965 100644
--- a/crates/bevy_reflect/derive/src/impls/enums.rs
+++ b/crates/bevy_reflect/derive/src/impls/enums.rs
@@ -62,8 +62,8 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
     let full_reflect_impl = impl_full_reflect(&where_clause_options);
     let common_methods = common_partial_reflect_methods(
         reflect_enum.meta(),
-        || Some(quote!(#bevy_reflect_path::enum_partial_eq)),
-        || Some(quote!(#bevy_reflect_path::enum_hash)),
+        || Some(quote!(#bevy_reflect_path::enums::enum_partial_eq)),
+        || Some(quote!(#bevy_reflect_path::enums::enum_hash)),
     );
     let clone_fn = reflect_enum.get_clone_impl();
 
@@ -97,7 +97,7 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
 
         #auto_register
 
-        impl #impl_generics #bevy_reflect_path::Enum for #enum_path #ty_generics #where_reflect_clause {
+        impl #impl_generics #bevy_reflect_path::enums::Enum for #enum_path #ty_generics #where_reflect_clause {
             fn field(&self, #ref_name: &str) -> #FQOption<&dyn #bevy_reflect_path::PartialReflect> {
                  match #match_this {
                     #(#enum_field,)*
@@ -140,8 +140,8 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
                 }
             }
 
-            fn iter_fields(&self) -> #bevy_reflect_path::VariantFieldIter {
-                #bevy_reflect_path::VariantFieldIter::new(self)
+            fn iter_fields(&self) -> #bevy_reflect_path::enums::VariantFieldIter {
+                #bevy_reflect_path::enums::VariantFieldIter::new(self)
             }
 
             #[inline]
@@ -169,15 +169,15 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
             }
 
             #[inline]
-            fn variant_type(&self) -> #bevy_reflect_path::VariantType {
+            fn variant_type(&self) -> #bevy_reflect_path::enums::VariantType {
                  match #match_this {
                     #(#enum_variant_type,)*
                     _ => unreachable!(),
                 }
             }
 
-            fn to_dynamic_enum(&self) -> #bevy_reflect_path::DynamicEnum {
-                #bevy_reflect_path::DynamicEnum::from_ref::<Self>(self)
+            fn to_dynamic_enum(&self) -> #bevy_reflect_path::enums::DynamicEnum {
+                #bevy_reflect_path::enums::DynamicEnum::from_ref::<Self>(self)
             }
         }
 
@@ -194,20 +194,20 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
             ) -> #FQResult<(), #bevy_reflect_path::ApplyError>  {
                 if let #bevy_reflect_path::ReflectRef::Enum(#ref_value) =
                     #bevy_reflect_path::PartialReflect::reflect_ref(#ref_value) {
-                    if #bevy_reflect_path::Enum::variant_name(self) == #bevy_reflect_path::Enum::variant_name(#ref_value) {
+                    if #bevy_reflect_path::enums::Enum::variant_name(self) == #bevy_reflect_path::enums::Enum::variant_name(#ref_value) {
                         // Same variant -> just update fields
-                        match #bevy_reflect_path::Enum::variant_type(#ref_value) {
-                            #bevy_reflect_path::VariantType::Struct => {
-                                for field in #bevy_reflect_path::Enum::iter_fields(#ref_value) {
+                        match #bevy_reflect_path::enums::Enum::variant_type(#ref_value) {
+                            #bevy_reflect_path::enums::VariantType::Struct => {
+                                for field in #bevy_reflect_path::enums::Enum::iter_fields(#ref_value) {
                                     let name = field.name().unwrap();
-                                    if let #FQOption::Some(v) = #bevy_reflect_path::Enum::field_mut(self, name) {
+                                    if let #FQOption::Some(v) = #bevy_reflect_path::enums::Enum::field_mut(self, name) {
                                        #bevy_reflect_path::PartialReflect::try_apply(v, field.value())?;
                                     }
                                 }
                             }
-                            #bevy_reflect_path::VariantType::Tuple => {
-                                for (index, field) in ::core::iter::Iterator::enumerate(#bevy_reflect_path::Enum::iter_fields(#ref_value)) {
-                                    if let #FQOption::Some(v) = #bevy_reflect_path::Enum::field_at_mut(self, index) {
+                            #bevy_reflect_path::enums::VariantType::Tuple => {
+                                for (index, field) in ::core::iter::Iterator::enumerate(#bevy_reflect_path::enums::Enum::iter_fields(#ref_value)) {
+                                    if let #FQOption::Some(v) = #bevy_reflect_path::enums::Enum::field_at_mut(self, index) {
                                         #bevy_reflect_path::PartialReflect::try_apply(v, field.value())?;
                                     }
                                 }
@@ -216,7 +216,7 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
                         }
                     } else {
                         // New variant -> perform a switch
-                        match #bevy_reflect_path::Enum::variant_name(#ref_value) {
+                        match #bevy_reflect_path::enums::Enum::variant_name(#ref_value) {
                             #(#variant_names => {
                                 #deref_this = #variant_constructors
                             })*
@@ -309,7 +309,7 @@ fn generate_impls(reflect_enum: &ReflectEnum, ref_index: &Ident, ref_name: &Iden
             #unit{..} => #variant_index
         });
         enum_variant_type.push(quote! {
-            #unit{..} => #bevy_reflect_path::VariantType::#variant_type_ident
+            #unit{..} => #bevy_reflect_path::enums::VariantType::#variant_type_ident
         });
 
         fn process_fields(
diff --git a/crates/bevy_reflect/derive/src/impls/structs.rs b/crates/bevy_reflect/derive/src/impls/structs.rs
index 730a9092a38a2..69dea3fb784de 100644
--- a/crates/bevy_reflect/derive/src/impls/structs.rs
+++ b/crates/bevy_reflect/derive/src/impls/structs.rs
@@ -40,7 +40,7 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> proc_macro2::TokenS
     let full_reflect_impl = impl_full_reflect(&where_clause_options);
     let common_methods = common_partial_reflect_methods(
         reflect_struct.meta(),
-        || Some(quote!(#bevy_reflect_path::struct_partial_eq)),
+        || Some(quote!(#bevy_reflect_path::structs::struct_partial_eq)),
         || None,
     );
     let clone_fn = reflect_struct.get_clone_impl();
@@ -78,7 +78,7 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> proc_macro2::TokenS
 
         #auto_register
 
-        impl #impl_generics #bevy_reflect_path::Struct for #struct_path #ty_generics #where_reflect_clause {
+        impl #impl_generics #bevy_reflect_path::structs::Struct for #struct_path #ty_generics #where_reflect_clause {
             fn field(&self, name: &str) -> #FQOption<&dyn #bevy_reflect_path::PartialReflect> {
                 match name {
                     #(#field_names => #fqoption::Some(#fields_ref),)*
@@ -118,12 +118,12 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> proc_macro2::TokenS
                 #field_count
             }
 
-            fn iter_fields(&self) -> #bevy_reflect_path::FieldIter {
-                #bevy_reflect_path::FieldIter::new(self)
+            fn iter_fields(&self) -> #bevy_reflect_path::structs::FieldIter {
+                #bevy_reflect_path::structs::FieldIter::new(self)
             }
 
-            fn to_dynamic_struct(&self) -> #bevy_reflect_path::DynamicStruct {
-                let mut dynamic: #bevy_reflect_path::DynamicStruct = #FQDefault::default();
+            fn to_dynamic_struct(&self) -> #bevy_reflect_path::structs::DynamicStruct {
+                let mut dynamic: #bevy_reflect_path::structs::DynamicStruct = #FQDefault::default();
                 dynamic.set_represented_type(#bevy_reflect_path::PartialReflect::get_represented_type_info(self));
                 #(dynamic.insert_boxed(#field_names, #bevy_reflect_path::PartialReflect::to_dynamic(#fields_ref));)*
                 dynamic
@@ -143,9 +143,9 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> proc_macro2::TokenS
             ) -> #FQResult<(), #bevy_reflect_path::ApplyError> {
                 if let #bevy_reflect_path::ReflectRef::Struct(struct_value)
                     = #bevy_reflect_path::PartialReflect::reflect_ref(value) {
-                    for (i, value) in ::core::iter::Iterator::enumerate(#bevy_reflect_path::Struct::iter_fields(struct_value)) {
-                        let name = #bevy_reflect_path::Struct::name_at(struct_value, i).unwrap();
-                        if let #FQOption::Some(v) = #bevy_reflect_path::Struct::field_mut(self, name) {
+                    for (i, value) in ::core::iter::Iterator::enumerate(#bevy_reflect_path::structs::Struct::iter_fields(struct_value)) {
+                        let name = #bevy_reflect_path::structs::Struct::name_at(struct_value, i).unwrap();
+                        if let #FQOption::Some(v) = #bevy_reflect_path::structs::Struct::field_mut(self, name) {
                            #bevy_reflect_path::PartialReflect::try_apply(v, value)?;
                         }
                     }
diff --git a/crates/bevy_reflect/derive/src/impls/tuple_structs.rs b/crates/bevy_reflect/derive/src/impls/tuple_structs.rs
index e9fb9bd009508..546fb4aaec60b 100644
--- a/crates/bevy_reflect/derive/src/impls/tuple_structs.rs
+++ b/crates/bevy_reflect/derive/src/impls/tuple_structs.rs
@@ -30,7 +30,7 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> proc_macro2::
     let full_reflect_impl = impl_full_reflect(&where_clause_options);
     let common_methods = common_partial_reflect_methods(
         reflect_struct.meta(),
-        || Some(quote!(#bevy_reflect_path::tuple_struct_partial_eq)),
+        || Some(quote!(#bevy_reflect_path::tuple_struct::tuple_struct_partial_eq)),
         || None,
     );
     let clone_fn = reflect_struct.get_clone_impl();
@@ -66,7 +66,7 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> proc_macro2::
 
         #auto_register
 
-        impl #impl_generics #bevy_reflect_path::TupleStruct for #struct_path #ty_generics #where_reflect_clause {
+        impl #impl_generics #bevy_reflect_path::tuple_struct::TupleStruct for #struct_path #ty_generics #where_reflect_clause {
             fn field(&self, index: usize) -> #FQOption<&dyn #bevy_reflect_path::PartialReflect> {
                 match index {
                     #(#field_indices => #fqoption::Some(#fields_ref),)*
@@ -85,12 +85,12 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> proc_macro2::
                 #field_count
             }
             #[inline]
-            fn iter_fields(&self) -> #bevy_reflect_path::TupleStructFieldIter {
-                #bevy_reflect_path::TupleStructFieldIter::new(self)
+            fn iter_fields(&self) -> #bevy_reflect_path::tuple_struct::TupleStructFieldIter {
+                #bevy_reflect_path::tuple_struct::TupleStructFieldIter::new(self)
             }
 
-            fn to_dynamic_tuple_struct(&self) -> #bevy_reflect_path::DynamicTupleStruct {
-                let mut dynamic: #bevy_reflect_path::DynamicTupleStruct = #FQDefault::default();
+            fn to_dynamic_tuple_struct(&self) -> #bevy_reflect_path::tuple_struct::DynamicTupleStruct {
+                let mut dynamic: #bevy_reflect_path::tuple_struct::DynamicTupleStruct = #FQDefault::default();
                 dynamic.set_represented_type(#bevy_reflect_path::PartialReflect::get_represented_type_info(self));
                 #(dynamic.insert_boxed(#bevy_reflect_path::PartialReflect::to_dynamic(#fields_ref));)*
                 dynamic
@@ -110,8 +110,8 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> proc_macro2::
             ) -> #FQResult<(), #bevy_reflect_path::ApplyError> {
                 if let #bevy_reflect_path::ReflectRef::TupleStruct(struct_value) =
                     #bevy_reflect_path::PartialReflect::reflect_ref(value) {
-                    for (i, value) in ::core::iter::Iterator::enumerate(#bevy_reflect_path::TupleStruct::iter_fields(struct_value)) {
-                        if let #FQOption::Some(v) = #bevy_reflect_path::TupleStruct::field_mut(self, i) {
+                    for (i, value) in ::core::iter::Iterator::enumerate(#bevy_reflect_path::tuple_struct::TupleStruct::iter_fields(struct_value)) {
+                        if let #FQOption::Some(v) = #bevy_reflect_path::tuple_struct::TupleStruct::field_mut(self, i) {
                             #bevy_reflect_path::PartialReflect::try_apply(v, value)?;
                         }
                     }
diff --git a/crates/bevy_reflect/src/array.rs b/crates/bevy_reflect/src/array.rs
index ceb0cea6965c8..410020b4b3a52 100644
--- a/crates/bevy_reflect/src/array.rs
+++ b/crates/bevy_reflect/src/array.rs
@@ -1,3 +1,6 @@
+//! Traits and types used to power [array-like] operations via reflection.
+//!
+//! [array-like]: https://doc.rust-lang.org/book/ch03-02-data-types.html#the-array-type
 use crate::generics::impl_generic_info_methods;
 use crate::{
     type_info::impl_type_methods, utility::reflect_hasher, ApplyError, Generics, MaybeTyped,
@@ -31,7 +34,7 @@ use core::{
 /// # Example
 ///
 /// ```
-/// use bevy_reflect::{PartialReflect, Array};
+/// use bevy_reflect::{PartialReflect, array::Array};
 ///
 /// let foo: &dyn Array = &[123_u32, 456_u32, 789_u32];
 /// assert_eq!(foo.len(), 3);
@@ -42,7 +45,7 @@ use core::{
 ///
 /// [array-like]: https://doc.rust-lang.org/book/ch03-02-data-types.html#the-array-type
 /// [reflection]: crate
-/// [`List`]: crate::List
+/// [`List`]: crate::list::List
 /// [type-erasing]: https://doc.rust-lang.org/book/ch17-02-trait-objects.html
 /// [`GetTypeRegistration`]: crate::GetTypeRegistration
 /// [limitation]: https://github.com/serde-rs/serde/issues/1937
@@ -159,7 +162,7 @@ impl ArrayInfo {
 /// This isn't to say that a [`DynamicArray`] is immutable— its items
 /// can be mutated— just that the _number_ of items cannot change.
 ///
-/// [`DynamicList`]: crate::DynamicList
+/// [`DynamicList`]: crate::list::DynamicList
 #[derive(Debug)]
 pub struct DynamicArray {
     pub(crate) represented_type: Option<&'static TypeInfo>,
diff --git a/crates/bevy_reflect/src/attributes.rs b/crates/bevy_reflect/src/attributes.rs
index 4d8154fad33b8..c9765ca5102b3 100644
--- a/crates/bevy_reflect/src/attributes.rs
+++ b/crates/bevy_reflect/src/attributes.rs
@@ -183,7 +183,7 @@ pub(crate) use impl_custom_attribute_methods;
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{type_info::Typed, TypeInfo, VariantInfo};
+    use crate::{enums::VariantInfo, type_info::Typed, TypeInfo};
     use alloc::{format, string::String};
     use core::ops::RangeInclusive;
 
diff --git a/crates/bevy_reflect/src/enums/dynamic_enum.rs b/crates/bevy_reflect/src/enums/dynamic_enum.rs
index 8f218a5f04bbc..b471491cfdb9f 100644
--- a/crates/bevy_reflect/src/enums/dynamic_enum.rs
+++ b/crates/bevy_reflect/src/enums/dynamic_enum.rs
@@ -1,9 +1,11 @@
 use bevy_reflect_derive::impl_type_path;
 
 use crate::{
-    enum_debug, enum_hash, enum_partial_eq, ApplyError, DynamicStruct, DynamicTuple, Enum,
-    PartialReflect, Reflect, ReflectKind, ReflectMut, ReflectOwned, ReflectRef, Struct, Tuple,
-    TypeInfo, VariantFieldIter, VariantType,
+    enums::{enum_debug, enum_hash, enum_partial_eq, Enum, VariantFieldIter, VariantType},
+    structs::{DynamicStruct, Struct},
+    tuple::{DynamicTuple, Tuple},
+    ApplyError, PartialReflect, Reflect, ReflectKind, ReflectMut, ReflectOwned, ReflectRef,
+    TypeInfo,
 };
 
 use alloc::{boxed::Box, string::String};
@@ -45,7 +47,7 @@ impl From<()> for DynamicVariant {
 /// # Example
 ///
 /// ```
-/// # use bevy_reflect::{DynamicEnum, DynamicVariant, Reflect, PartialReflect};
+/// # use bevy_reflect::{enums::{DynamicEnum, DynamicVariant}, Reflect, PartialReflect};
 ///
 /// // The original enum value
 /// let mut value: Option<usize> = Some(123);
diff --git a/crates/bevy_reflect/src/enums/enum_trait.rs b/crates/bevy_reflect/src/enums/enum_trait.rs
index e1edb792ed7ce..09eb7e1a1e75d 100644
--- a/crates/bevy_reflect/src/enums/enum_trait.rs
+++ b/crates/bevy_reflect/src/enums/enum_trait.rs
@@ -1,8 +1,9 @@
 use crate::generics::impl_generic_info_methods;
 use crate::{
     attributes::{impl_custom_attribute_methods, CustomAttributes},
+    enums::{DynamicEnum, VariantInfo, VariantType},
     type_info::impl_type_methods,
-    DynamicEnum, Generics, PartialReflect, Type, TypePath, VariantInfo, VariantType,
+    Generics, PartialReflect, Type, TypePath,
 };
 use alloc::{boxed::Box, format, string::String};
 use bevy_platform::collections::HashMap;
@@ -325,7 +326,7 @@ impl<'a> VariantField<'a> {
 // Tests that need access to internal fields have to go here rather than in mod.rs
 #[cfg(test)]
 mod tests {
-    use crate::*;
+    use crate::{enums::*, Reflect};
 
     #[derive(Reflect, Debug, PartialEq)]
     enum MyEnum {
diff --git a/crates/bevy_reflect/src/enums/helpers.rs b/crates/bevy_reflect/src/enums/helpers.rs
index 659d0bd7bc823..42bd27048f871 100644
--- a/crates/bevy_reflect/src/enums/helpers.rs
+++ b/crates/bevy_reflect/src/enums/helpers.rs
@@ -1,4 +1,8 @@
-use crate::{utility::reflect_hasher, Enum, PartialReflect, ReflectRef, VariantType};
+use crate::{
+    enums::{Enum, VariantType},
+    utility::reflect_hasher,
+    PartialReflect, ReflectRef,
+};
 use core::{
     fmt::Debug,
     hash::{Hash, Hasher},
diff --git a/crates/bevy_reflect/src/enums/mod.rs b/crates/bevy_reflect/src/enums/mod.rs
index fd657ffa7f25a..11bf73de3d1f2 100644
--- a/crates/bevy_reflect/src/enums/mod.rs
+++ b/crates/bevy_reflect/src/enums/mod.rs
@@ -1,3 +1,6 @@
+//! Traits and types used to power [enum-like] operations via reflection.
+//!
+//! [enum-like]: https://doc.rust-lang.org/book/ch06-01-defining-an-enum.html
 mod dynamic_enum;
 mod enum_trait;
 mod helpers;
@@ -10,7 +13,7 @@ pub use variants::*;
 
 #[cfg(test)]
 mod tests {
-    use crate::*;
+    use crate::{enums::*, structs::*, tuple::*, *};
     use alloc::boxed::Box;
 
     #[derive(Reflect, Debug, PartialEq)]
diff --git a/crates/bevy_reflect/src/from_reflect.rs b/crates/bevy_reflect/src/from_reflect.rs
index dc113d869f3c7..d1c55a26305a6 100644
--- a/crates/bevy_reflect/src/from_reflect.rs
+++ b/crates/bevy_reflect/src/from_reflect.rs
@@ -20,7 +20,7 @@ use alloc::boxed::Box;
 /// See the [crate-level documentation] to see how this trait can be used.
 ///
 /// [derive macro]: bevy_reflect_derive::FromReflect
-/// [`DynamicStruct`]: crate::DynamicStruct
+/// [`DynamicStruct`]: crate::structs::DynamicStruct
 /// [crate-level documentation]: crate
 #[diagnostic::on_unimplemented(
     message = "`{Self}` does not implement `FromReflect` so cannot be created through reflection",
@@ -38,8 +38,8 @@ pub trait FromReflect: Reflect + Sized {
     /// rather than a boxed dynamic type (e.g. [`DynamicStruct`], [`DynamicList`], etc.).
     ///
     /// [`from_reflect`]: Self::from_reflect
-    /// [`DynamicStruct`]: crate::DynamicStruct
-    /// [`DynamicList`]: crate::DynamicList
+    /// [`DynamicStruct`]: crate::structs::DynamicStruct
+    /// [`DynamicList`]: crate::list::DynamicList
     fn take_from_reflect(
         reflect: Box<dyn PartialReflect>,
     ) -> Result<Self, Box<dyn PartialReflect>> {
@@ -62,7 +62,7 @@ pub trait FromReflect: Reflect + Sized {
 /// However, to do this, you normally need to specify the exact concrete type:
 ///
 /// ```
-/// # use bevy_reflect::{DynamicTupleStruct, FromReflect, Reflect};
+/// # use bevy_reflect::{tuple_struct::DynamicTupleStruct, FromReflect, Reflect};
 /// #[derive(Reflect, PartialEq, Eq, Debug)]
 /// struct Foo(#[reflect(default = "default_value")] usize);
 ///
@@ -82,7 +82,7 @@ pub trait FromReflect: Reflect + Sized {
 /// # Example
 ///
 /// ```
-/// # use bevy_reflect::{DynamicTupleStruct, Reflect, ReflectFromReflect, Typed, TypeRegistry, TypePath};
+/// # use bevy_reflect::{tuple_struct::DynamicTupleStruct, Reflect, ReflectFromReflect, Typed, TypeRegistry, TypePath};
 /// # #[derive(Reflect, PartialEq, Eq, Debug)]
 /// # struct Foo(#[reflect(default = "default_value")] usize);
 /// # fn default_value() -> usize { 123 }
@@ -100,8 +100,8 @@ pub trait FromReflect: Reflect + Sized {
 /// assert_eq!(Foo(123), concrete.take::<Foo>().unwrap());
 /// ```
 ///
-/// [`DynamicStruct`]: crate::DynamicStruct
-/// [`DynamicEnum`]: crate::DynamicEnum
+/// [`DynamicStruct`]: crate::structs::DynamicStruct
+/// [`DynamicEnum`]: crate::enums::DynamicEnum
 #[derive(Clone)]
 pub struct ReflectFromReflect {
     from_reflect: fn(&dyn PartialReflect) -> Option<Box<dyn Reflect>>,
diff --git a/crates/bevy_reflect/src/impls/alloc/borrow.rs b/crates/bevy_reflect/src/impls/alloc/borrow.rs
index 8326ff9728922..3e9cc8c8774ef 100644
--- a/crates/bevy_reflect/src/impls/alloc/borrow.rs
+++ b/crates/bevy_reflect/src/impls/alloc/borrow.rs
@@ -245,19 +245,19 @@ impl<T: FromReflect + MaybeTyped + Clone + TypePath + GetTypeRegistration> Parti
     }
 
     fn reflect_hash(&self) -> Option<u64> {
-        crate::list_hash(self)
+        crate::list::list_hash(self)
     }
 
     fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool> {
-        crate::list_partial_eq(self, value)
+        crate::list::list_partial_eq(self, value)
     }
 
     fn apply(&mut self, value: &dyn PartialReflect) {
-        crate::list_apply(self, value);
+        crate::list::list_apply(self, value);
     }
 
     fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError> {
-        crate::list_try_apply(self, value)
+        crate::list::list_try_apply(self, value)
     }
 }
 
diff --git a/crates/bevy_reflect/src/impls/core/option.rs b/crates/bevy_reflect/src/impls/core/option.rs
index fe8318806d23c..88278e3314e62 100644
--- a/crates/bevy_reflect/src/impls/core/option.rs
+++ b/crates/bevy_reflect/src/impls/core/option.rs
@@ -15,7 +15,10 @@ impl_reflect! {
 
 #[cfg(test)]
 mod tests {
-    use crate::{Enum, FromReflect, PartialReflect, TypeInfo, Typed, VariantInfo, VariantType};
+    use crate::{
+        enums::{Enum, VariantInfo, VariantType},
+        FromReflect, PartialReflect, TypeInfo, Typed,
+    };
     use bevy_reflect_derive::Reflect;
     use static_assertions::assert_impl_all;
 
diff --git a/crates/bevy_reflect/src/impls/core/primitives.rs b/crates/bevy_reflect/src/impls/core/primitives.rs
index 8d53193ac6d03..7f15afdb85ad5 100644
--- a/crates/bevy_reflect/src/impls/core/primitives.rs
+++ b/crates/bevy_reflect/src/impls/core/primitives.rs
@@ -376,21 +376,21 @@ impl<T: Reflect + MaybeTyped + TypePath + GetTypeRegistration, const N: usize> P
 
     #[inline]
     fn reflect_hash(&self) -> Option<u64> {
-        crate::array_hash(self)
+        crate::array::array_hash(self)
     }
 
     #[inline]
     fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool> {
-        crate::array_partial_eq(self, value)
+        crate::array::array_partial_eq(self, value)
     }
 
     fn apply(&mut self, value: &dyn PartialReflect) {
-        crate::array_apply(self, value);
+        crate::array::array_apply(self, value);
     }
 
     #[inline]
     fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError> {
-        crate::array_try_apply(self, value)
+        crate::array::array_try_apply(self, value)
     }
 }
 
diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index 139557ddb61a2..84aabb694c3df 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -517,9 +517,10 @@ mod tests {
     use static_assertions::assert_impl_all;
 
     use crate::{
+        enums::Enum,
         prelude::*,
         serde::{ReflectDeserializer, ReflectSerializer},
-        Enum, GetTypeRegistration, TypeRegistry,
+        GetTypeRegistration, TypeRegistry,
     };
 
     use super::*;
diff --git a/crates/bevy_reflect/src/impls/indexmap.rs b/crates/bevy_reflect/src/impls/indexmap.rs
index cefceb7e8e304..d7e4ea21d5638 100644
--- a/crates/bevy_reflect/src/impls/indexmap.rs
+++ b/crates/bevy_reflect/src/impls/indexmap.rs
@@ -1,11 +1,14 @@
 use crate::{
-    utility::GenericTypeInfoCell, FromReflect, FromType, Generics, GetTypeRegistration,
-    PartialReflect, Reflect, ReflectCloneError, ReflectFromPtr, ReflectMut, ReflectOwned,
-    ReflectRef, Set, SetInfo, TypeInfo, TypeParamInfo, TypePath, TypeRegistration,
+    set::{Set, SetInfo},
+    utility::GenericTypeInfoCell,
+    FromReflect, FromType, Generics, GetTypeRegistration, PartialReflect, Reflect,
+    ReflectCloneError, ReflectFromPtr, ReflectMut, ReflectOwned, ReflectRef, TypeInfo,
+    TypeParamInfo, TypePath, TypeRegistration,
 };
 use bevy_platform::prelude::{Box, Vec};
 use bevy_reflect::{
-    DynamicMap, Map, MapInfo, MaybeTyped, ReflectFromReflect, ReflectKind, TypeRegistry, Typed,
+    map::{DynamicMap, Map, MapInfo},
+    MaybeTyped, ReflectFromReflect, ReflectKind, TypeRegistry, Typed,
 };
 use bevy_reflect_derive::impl_type_path;
 use core::{any::Any, hash::BuildHasher, hash::Hash};
@@ -140,11 +143,11 @@ where
     }
 
     fn apply(&mut self, value: &dyn PartialReflect) {
-        crate::map_apply(self, value);
+        crate::map::map_apply(self, value);
     }
 
     fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), crate::ApplyError> {
-        crate::map_try_apply(self, value)
+        crate::map::map_try_apply(self, value)
     }
 
     fn reflect_kind(&self) -> ReflectKind {
@@ -175,7 +178,7 @@ where
     }
 
     fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool> {
-        crate::map_partial_eq(self, value)
+        crate::map::map_partial_eq(self, value)
     }
 }
 
@@ -376,11 +379,11 @@ where
     }
 
     fn apply(&mut self, value: &dyn PartialReflect) {
-        crate::set_apply(self, value);
+        crate::set::set_apply(self, value);
     }
 
     fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), crate::ApplyError> {
-        crate::set_try_apply(self, value)
+        crate::set::set_try_apply(self, value)
     }
 
     fn reflect_kind(&self) -> ReflectKind {
@@ -408,7 +411,7 @@ where
     }
 
     fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool> {
-        crate::set_partial_eq(self, value)
+        crate::set::set_partial_eq(self, value)
     }
 }
 
diff --git a/crates/bevy_reflect/src/impls/smallvec.rs b/crates/bevy_reflect/src/impls/smallvec.rs
index 21e5240683178..7872fe2d3e54e 100644
--- a/crates/bevy_reflect/src/impls/smallvec.rs
+++ b/crates/bevy_reflect/src/impls/smallvec.rs
@@ -1,8 +1,9 @@
 use crate::{
-    utility::GenericTypeInfoCell, ApplyError, FromReflect, FromType, Generics, GetTypeRegistration,
-    List, ListInfo, ListIter, MaybeTyped, PartialReflect, Reflect, ReflectFromPtr, ReflectKind,
-    ReflectMut, ReflectOwned, ReflectRef, TypeInfo, TypeParamInfo, TypePath, TypeRegistration,
-    Typed,
+    list::{List, ListInfo, ListIter},
+    utility::GenericTypeInfoCell,
+    ApplyError, FromReflect, FromType, Generics, GetTypeRegistration, MaybeTyped, PartialReflect,
+    Reflect, ReflectFromPtr, ReflectKind, ReflectMut, ReflectOwned, ReflectRef, TypeInfo,
+    TypeParamInfo, TypePath, TypeRegistration, Typed,
 };
 use alloc::{boxed::Box, vec::Vec};
 use bevy_reflect::ReflectCloneError;
@@ -112,11 +113,11 @@ where
     }
 
     fn apply(&mut self, value: &dyn PartialReflect) {
-        crate::list_apply(self, value);
+        crate::list::list_apply(self, value);
     }
 
     fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError> {
-        crate::list_try_apply(self, value)
+        crate::list::list_try_apply(self, value)
     }
 
     fn reflect_kind(&self) -> ReflectKind {
@@ -147,7 +148,7 @@ where
     }
 
     fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool> {
-        crate::list_partial_eq(self, value)
+        crate::list::list_partial_eq(self, value)
     }
 }
 
diff --git a/crates/bevy_reflect/src/kind.rs b/crates/bevy_reflect/src/kind.rs
index e8a2310b0f49d..109ab7f7dcca5 100644
--- a/crates/bevy_reflect/src/kind.rs
+++ b/crates/bevy_reflect/src/kind.rs
@@ -3,7 +3,10 @@ use thiserror::Error;
 
 #[cfg(feature = "functions")]
 use crate::func::Function;
-use crate::{Array, Enum, List, Map, PartialReflect, Set, Struct, Tuple, TupleStruct};
+use crate::{
+    array::Array, enums::Enum, list::List, map::Map, set::Set, structs::Struct, tuple::Tuple,
+    tuple_struct::TupleStruct, PartialReflect,
+};
 
 /// An enumeration of the "kinds" of a reflected type.
 ///
diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs
index c13c5ea752125..ed75dd35d6d4a 100644
--- a/crates/bevy_reflect/src/lib.rs
+++ b/crates/bevy_reflect/src/lib.rs
@@ -135,7 +135,7 @@
 //! For example, we can access our struct's fields by name using the [`Struct::field`] method.
 //!
 //! ```
-//! # use bevy_reflect::{PartialReflect, Reflect, Struct};
+//! # use bevy_reflect::{PartialReflect, Reflect, structs::Struct};
 //! # #[derive(Reflect)]
 //! # struct MyStruct {
 //! #   foo: i32
@@ -195,7 +195,7 @@
 //! These dynamic types may contain any arbitrary reflected data.
 //!
 //! ```
-//! # use bevy_reflect::{DynamicStruct, Struct};
+//! # use bevy_reflect::structs::{DynamicStruct, Struct};
 //! let mut data = DynamicStruct::default();
 //! data.insert("foo", 123_i32);
 //! assert_eq!(Some(&123), data.field("foo").unwrap().try_downcast_ref::<i32>())
@@ -209,7 +209,7 @@
 //! we may pass them around just like most other reflected types.
 //!
 //! ```
-//! # use bevy_reflect::{DynamicStruct, PartialReflect, Reflect};
+//! # use bevy_reflect::{structs::DynamicStruct, PartialReflect, Reflect};
 //! # #[derive(Reflect)]
 //! # struct MyStruct {
 //! #   foo: i32
@@ -229,7 +229,7 @@
 //! This is known as "patching" and is done using the [`PartialReflect::apply`] and [`PartialReflect::try_apply`] methods.
 //!
 //! ```
-//! # use bevy_reflect::{DynamicEnum, PartialReflect};
+//! # use bevy_reflect::{enums::DynamicEnum, PartialReflect};
 //! let mut value = Some(123_i32);
 //! let patch = DynamicEnum::new("None", ());
 //! value.apply(&patch);
@@ -243,7 +243,7 @@
 //! or when trying to make use of a reflected trait which expects the actual type.
 //!
 //! ```should_panic
-//! # use bevy_reflect::{DynamicStruct, PartialReflect, Reflect};
+//! # use bevy_reflect::{structs::DynamicStruct, PartialReflect, Reflect};
 //! # #[derive(Reflect)]
 //! # struct MyStruct {
 //! #   foo: i32
@@ -541,7 +541,23 @@
 //! [the language feature for dyn upcasting coercion]: https://github.com/rust-lang/rust/issues/65991
 //! [derive macro]: derive@crate::Reflect
 //! [`'static` lifetime]: https://doc.rust-lang.org/rust-by-example/scope/lifetime/static_lifetime.html#trait-bound
+//! [`Tuple`]: crate::tuple::Tuple
+//! [`Array`]: crate::array::Array
+//! [`List`]: crate::list::List
+//! [`Set`]: crate::set::Set
+//! [`Map`]: crate::map::Map
+//! [`Struct`]: crate::structs::Struct
+//! [`TupleStruct`]: crate::tuple_struct::TupleStruct
+//! [`Enum`]: crate::enums::Enum
 //! [`Function`]: crate::func::Function
+//! [`Struct::field`]: crate::structs::Struct::field
+//! [`DynamicTuple`]: crate::tuple::DynamicTuple
+//! [`DynamicArray`]: crate::array::DynamicArray
+//! [`DynamicList`]: crate::list::DynamicList
+//! [`DynamicMap`]: crate::map::DynamicMap
+//! [`DynamicStruct`]: crate::structs::DynamicStruct
+//! [`DynamicTupleStruct`]: crate::tuple_struct::DynamicTupleStruct
+//! [`DynamicEnum`]: crate::enums::DynamicEnum
 //! [derive macro documentation]: derive@crate::Reflect
 //! [deriving `Reflect`]: derive@crate::Reflect
 //! [type data]: TypeData
@@ -578,7 +594,7 @@ extern crate alloc;
 // Required to make proc macros work in bevy itself.
 extern crate self as bevy_reflect;
 
-mod array;
+pub mod array;
 mod error;
 mod fields;
 mod from_reflect;
@@ -586,16 +602,16 @@ mod from_reflect;
 pub mod func;
 mod is;
 mod kind;
-mod list;
-mod map;
+pub mod list;
+pub mod map;
 mod path;
 mod reflect;
 mod reflectable;
 mod remote;
-mod set;
-mod struct_trait;
-mod tuple;
-mod tuple_struct;
+pub mod set;
+pub mod structs;
+pub mod tuple;
+pub mod tuple_struct;
 mod type_info;
 mod type_path;
 mod type_registry;
@@ -628,7 +644,7 @@ mod impls {
 }
 
 pub mod attributes;
-mod enums;
+pub mod enums;
 mod generics;
 pub mod serde;
 pub mod std_traits;
@@ -644,33 +660,27 @@ pub mod prelude {
 
     #[doc(hidden)]
     pub use crate::{
-        reflect_trait, FromReflect, GetField, GetPath, GetTupleStructField, PartialReflect,
-        Reflect, ReflectDeserialize, ReflectFromReflect, ReflectPath, ReflectSerialize, Struct,
-        TupleStruct, TypePath,
+        reflect_trait,
+        structs::{GetField, Struct},
+        tuple_struct::{GetTupleStructField, TupleStruct},
+        FromReflect, GetPath, PartialReflect, Reflect, ReflectDeserialize, ReflectFromReflect,
+        ReflectPath, ReflectSerialize, TypePath,
     };
 
     #[cfg(feature = "functions")]
     pub use crate::func::{Function, IntoFunction, IntoFunctionMut};
 }
 
-pub use array::*;
-pub use enums::*;
 pub use error::*;
 pub use fields::*;
 pub use from_reflect::*;
 pub use generics::*;
 pub use is::*;
 pub use kind::*;
-pub use list::*;
-pub use map::*;
 pub use path::*;
 pub use reflect::*;
 pub use reflectable::*;
 pub use remote::*;
-pub use set::*;
-pub use struct_trait::*;
-pub use tuple::*;
-pub use tuple_struct::*;
 pub use type_info::*;
 pub use type_path::*;
 pub use type_registry::*;
@@ -684,8 +694,9 @@ pub use erased_serde;
 #[doc(hidden)]
 pub mod __macro_exports {
     use crate::{
-        DynamicArray, DynamicEnum, DynamicList, DynamicMap, DynamicStruct, DynamicTuple,
-        DynamicTupleStruct, GetTypeRegistration, TypeRegistry,
+        array::DynamicArray, enums::DynamicEnum, list::DynamicList, map::DynamicMap,
+        structs::DynamicStruct, tuple::DynamicTuple, tuple_struct::DynamicTupleStruct,
+        GetTypeRegistration, TypeRegistry,
     };
 
     /// Re-exports of items from the [`alloc`] crate.
@@ -864,7 +875,9 @@ mod tests {
     };
     use static_assertions::{assert_impl_all, assert_not_impl_all};
 
-    use super::{prelude::*, *};
+    use super::{
+        array::*, enums::*, list::*, map::*, prelude::*, structs::*, tuple::*, tuple_struct::*, *,
+    };
     use crate::{
         serde::{ReflectDeserializer, ReflectSerializer},
         utility::GenericTypePathCell,
diff --git a/crates/bevy_reflect/src/list.rs b/crates/bevy_reflect/src/list.rs
index 51d65cac36f08..4e92594fbc797 100644
--- a/crates/bevy_reflect/src/list.rs
+++ b/crates/bevy_reflect/src/list.rs
@@ -1,3 +1,6 @@
+//! Traits and types used to power [list-like] operations via reflection.
+//!
+//! [list-like]: https://doc.rust-lang.org/book/ch08-01-vectors.html
 use alloc::{boxed::Box, vec::Vec};
 use core::{
     any::Any,
@@ -19,7 +22,7 @@ use crate::{
 /// This corresponds to types, like [`Vec`], which contain an ordered sequence
 /// of elements that implement [`Reflect`].
 ///
-/// Unlike the [`Array`](crate::Array) trait, implementors of this trait are not expected to
+/// Unlike the [`Array`](crate::array::Array) trait, implementors of this trait are not expected to
 /// maintain a constant length.
 /// Methods like [insertion](List::insert) and [removal](List::remove) explicitly allow for their
 /// internal size to change.
@@ -39,7 +42,7 @@ use crate::{
 /// # Example
 ///
 /// ```
-/// use bevy_reflect::{PartialReflect, Reflect, List};
+/// use bevy_reflect::{PartialReflect, Reflect, list::List};
 ///
 /// let foo: &mut dyn List = &mut vec![123_u32, 456_u32, 789_u32];
 /// assert_eq!(foo.len(), 3);
diff --git a/crates/bevy_reflect/src/map.rs b/crates/bevy_reflect/src/map.rs
index d4bc57948dc3c..ec497daa184d0 100644
--- a/crates/bevy_reflect/src/map.rs
+++ b/crates/bevy_reflect/src/map.rs
@@ -1,3 +1,6 @@
+//! Traits and types used to power [map-like] operations via reflection.
+//!
+//! [map-like]: https://doc.rust-lang.org/book/ch08-03-hash-maps.html
 use core::fmt::{Debug, Formatter};
 
 use bevy_platform::collections::HashTable;
@@ -29,7 +32,7 @@ use alloc::{boxed::Box, format, vec::Vec};
 /// # Example
 ///
 /// ```
-/// use bevy_reflect::{PartialReflect, Reflect, Map};
+/// use bevy_reflect::{PartialReflect, Reflect, map::Map};
 /// use std::collections::HashMap;
 ///
 ///
diff --git a/crates/bevy_reflect/src/path/access.rs b/crates/bevy_reflect/src/path/access.rs
index c0a141fcbaee1..e1f55d5962361 100644
--- a/crates/bevy_reflect/src/path/access.rs
+++ b/crates/bevy_reflect/src/path/access.rs
@@ -4,7 +4,7 @@ use alloc::borrow::Cow;
 use core::fmt;
 
 use super::error::AccessErrorKind;
-use crate::{AccessError, PartialReflect, ReflectKind, ReflectMut, ReflectRef, VariantType};
+use crate::{enums::VariantType, AccessError, PartialReflect, ReflectKind, ReflectMut, ReflectRef};
 
 type InnerResult<T> = Result<T, AccessErrorKind>;
 
diff --git a/crates/bevy_reflect/src/path/error.rs b/crates/bevy_reflect/src/path/error.rs
index 3287333b89f31..d2c9338767e35 100644
--- a/crates/bevy_reflect/src/path/error.rs
+++ b/crates/bevy_reflect/src/path/error.rs
@@ -1,7 +1,7 @@
 use core::fmt;
 
 use super::Access;
-use crate::{ReflectKind, VariantType};
+use crate::{enums::VariantType, ReflectKind};
 
 /// The kind of [`AccessError`], along with some kind-specific information.
 #[derive(Debug, PartialEq, Eq, Clone)]
diff --git a/crates/bevy_reflect/src/path/mod.rs b/crates/bevy_reflect/src/path/mod.rs
index fad18746c27b5..866add0bffce5 100644
--- a/crates/bevy_reflect/src/path/mod.rs
+++ b/crates/bevy_reflect/src/path/mod.rs
@@ -238,12 +238,12 @@ impl<'a> ReflectPath<'a> for &'a str {
 /// );
 /// ```
 ///
-/// [`Struct`]: crate::Struct
-/// [`Tuple`]: crate::Tuple
-/// [`TupleStruct`]: crate::TupleStruct
-/// [`List`]: crate::List
-/// [`Array`]: crate::Array
-/// [`Enum`]: crate::Enum
+/// [`Struct`]: crate::structs::Struct
+/// [`Tuple`]: crate::tuple::Tuple
+/// [`TupleStruct`]: crate::tuple_struct::TupleStruct
+/// [`List`]: crate::list::List
+/// [`Array`]: crate::array::Array
+/// [`Enum`]: crate::enums::Enum
 #[diagnostic::on_unimplemented(
     message = "`{Self}` does not implement `GetPath` so cannot be accessed by reflection path",
     note = "consider annotating `{Self}` with `#[derive(Reflect)]`"
@@ -274,7 +274,7 @@ pub trait GetPath: PartialReflect {
     /// The downcast will fail if this value is not of type `T`
     /// (which may be the case when using dynamic types like [`DynamicStruct`]).
     ///
-    /// [`DynamicStruct`]: crate::DynamicStruct
+    /// [`DynamicStruct`]: crate::structs::DynamicStruct
     fn path<'p, T: Reflect>(&self, path: impl ReflectPath<'p>) -> PathResult<'p, &T> {
         path.element(self.as_partial_reflect())
     }
@@ -285,7 +285,7 @@ pub trait GetPath: PartialReflect {
     /// The downcast will fail if this value is not of type `T`
     /// (which may be the case when using dynamic types like [`DynamicStruct`]).
     ///
-    /// [`DynamicStruct`]: crate::DynamicStruct
+    /// [`DynamicStruct`]: crate::structs::DynamicStruct
     fn path_mut<'p, T: Reflect>(&mut self, path: impl ReflectPath<'p>) -> PathResult<'p, &mut T> {
         path.element_mut(self.as_partial_reflect_mut())
     }
@@ -519,7 +519,7 @@ impl core::ops::IndexMut<usize> for ParsedPath {
 )]
 mod tests {
     use super::*;
-    use crate::*;
+    use crate::{enums::VariantType, *};
     use alloc::vec;
 
     #[derive(Reflect, PartialEq, Debug)]
diff --git a/crates/bevy_reflect/src/reflect.rs b/crates/bevy_reflect/src/reflect.rs
index 8dce19a925e99..cfd659a60abf2 100644
--- a/crates/bevy_reflect/src/reflect.rs
+++ b/crates/bevy_reflect/src/reflect.rs
@@ -1,7 +1,8 @@
 use crate::{
-    array_debug, enum_debug, list_debug, map_debug, set_debug, struct_debug, tuple_debug,
-    tuple_struct_debug, DynamicTypePath, DynamicTyped, OpaqueInfo, ReflectCloneError, ReflectKind,
-    ReflectKindMismatchError, ReflectMut, ReflectOwned, ReflectRef, TypeInfo, TypePath, Typed,
+    array::array_debug, enums::enum_debug, list::list_debug, map::map_debug, set::set_debug,
+    structs::struct_debug, tuple::tuple_debug, tuple_struct::tuple_struct_debug, DynamicTypePath,
+    DynamicTyped, OpaqueInfo, ReflectCloneError, ReflectKind, ReflectKindMismatchError, ReflectMut,
+    ReflectOwned, ReflectRef, TypeInfo, TypePath, Typed,
 };
 use alloc::borrow::Cow;
 use alloc::boxed::Box;
@@ -48,7 +49,7 @@ pub enum ApplyError {
     #[error("attempted to apply type with {from_size} size to a type with {to_size} size")]
     /// Attempted to apply an [array-like] type to another of different size, e.g. a [u8; 4] to [u8; 3].
     ///
-    /// [array-like]: crate::Array
+    /// [array-like]: crate::array::Array
     DifferentSize {
         /// Size of the value we attempted to apply, in elements.
         from_size: usize,
@@ -88,9 +89,9 @@ impl From<ReflectKindMismatchError> for ApplyError {
 ///
 /// [`bevy_reflect`]: crate
 /// [the derive macro for `Reflect`]: bevy_reflect_derive::Reflect
-/// [`Struct`]: crate::Struct
-/// [`TupleStruct`]: crate::TupleStruct
-/// [`Enum`]: crate::Enum
+/// [`Struct`]: crate::structs::Struct
+/// [`TupleStruct`]: crate::tuple_struct::TupleStruct
+/// [`Enum`]: crate::enums::Enum
 /// [crate-level documentation]: crate
 #[diagnostic::on_unimplemented(
     message = "`{Self}` does not implement `PartialReflect` so cannot be introspected",
@@ -113,8 +114,8 @@ where
     /// frequently, consider using [`TypeRegistry::get_type_info`] as it can be more
     /// performant for such use cases.
     ///
-    /// [`DynamicStruct`]: crate::DynamicStruct
-    /// [`DynamicList`]: crate::DynamicList
+    /// [`DynamicStruct`]: crate::structs::DynamicStruct
+    /// [`DynamicList`]: crate::list::DynamicList
     /// [`TypeRegistry::get_type_info`]: crate::TypeRegistry::get_type_info
     fn get_represented_type_info(&self) -> Option<&'static TypeInfo>;
 
@@ -181,17 +182,17 @@ where
     /// [`list_apply`], [`map_apply`], and [`set_apply`] helper functions when implementing this method.
     ///
     /// [reflection subtrait]: crate#the-reflection-subtraits
-    /// [`Struct`]: crate::Struct
-    /// [`TupleStruct`]: crate::TupleStruct
-    /// [`Tuple`]: crate::Tuple
-    /// [`Enum`]: crate::Enum
-    /// [`List`]: crate::List
-    /// [`Array`]: crate::Array
-    /// [`Map`]: crate::Map
-    /// [`Set`]: crate::Set
-    /// [`list_apply`]: crate::list_apply
-    /// [`map_apply`]: crate::map_apply
-    /// [`set_apply`]: crate::set_apply
+    /// [`Struct`]: crate::structs::Struct
+    /// [`TupleStruct`]: crate::tuple_struct::TupleStruct
+    /// [`Tuple`]: crate::tuple::Tuple
+    /// [`Enum`]: crate::enums::Enum
+    /// [`List`]: crate::list::List
+    /// [`Array`]: crate::array::Array
+    /// [`Map`]: crate::map::Map
+    /// [`Set`]: crate::set::Set
+    /// [`list_apply`]: crate::list::list_apply
+    /// [`map_apply`]: crate::map::map_apply
+    /// [`set_apply`]: crate::set::set_apply
     ///
     /// # Panics
     ///
@@ -264,12 +265,12 @@ where
     /// ```
     ///
     /// [kind]: PartialReflect::reflect_kind
-    /// [`List`]: crate::List
-    /// [`List::to_dynamic_list`]: crate::List::to_dynamic_list
-    /// [`DynamicList`]: crate::DynamicList
-    /// [`Struct`]: crate::Struct
-    /// [`Struct::to_dynamic_struct`]: crate::Struct::to_dynamic_struct
-    /// [`DynamicStruct`]: crate::DynamicStruct
+    /// [`List`]: crate::list::List
+    /// [`List::to_dynamic_list`]: crate::list::List::to_dynamic_list
+    /// [`DynamicList`]: crate::list::DynamicList
+    /// [`Struct`]: crate::structs::Struct
+    /// [`Struct::to_dynamic_struct`]: crate::structs::Struct::to_dynamic_struct
+    /// [`DynamicStruct`]: crate::structs::DynamicStruct
     /// [opaque]: crate::ReflectKind::Opaque
     /// [`reflect_clone`]: PartialReflect::reflect_clone
     fn to_dynamic(&self) -> Box<dyn PartialReflect> {
@@ -351,8 +352,8 @@ where
     /// (e.g. [`List`], [`Map`]), will default to the format: `"Reflect(type_path)"`,
     /// where `type_path` is the [type path] of the underlying type.
     ///
-    /// [`List`]: crate::List
-    /// [`Map`]: crate::Map
+    /// [`List`]: crate::list::List
+    /// [`Map`]: crate::map::Map
     /// [type path]: TypePath::type_path
     fn debug(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self.reflect_ref() {
@@ -379,9 +380,9 @@ where
     ///
     /// By default, this method will return `false`.
     ///
-    /// [`DynamicStruct`]: crate::DynamicStruct
-    /// [`DynamicList`]: crate::DynamicList
-    /// [`DynamicTuple`]: crate::DynamicTuple
+    /// [`DynamicStruct`]: crate::structs::DynamicStruct
+    /// [`DynamicList`]: crate::list::DynamicList
+    /// [`DynamicTuple`]: crate::tuple::DynamicTuple
     fn is_dynamic(&self) -> bool {
         false
     }
@@ -403,9 +404,9 @@ where
 ///
 /// [`bevy_reflect`]: crate
 /// [the derive macro]: bevy_reflect_derive::Reflect
-/// [`Struct`]: crate::Struct
-/// [`TupleStruct`]: crate::TupleStruct
-/// [`Enum`]: crate::Enum
+/// [`Struct`]: crate::structs::Struct
+/// [`TupleStruct`]: crate::tuple_struct::TupleStruct
+/// [`Enum`]: crate::enums::Enum
 /// [`Reflectable`]: crate::Reflectable
 /// [crate-level documentation]: crate
 #[diagnostic::on_unimplemented(
diff --git a/crates/bevy_reflect/src/serde/de/arrays.rs b/crates/bevy_reflect/src/serde/de/arrays.rs
index f1e0d60dd6154..fd3f369324f0b 100644
--- a/crates/bevy_reflect/src/serde/de/arrays.rs
+++ b/crates/bevy_reflect/src/serde/de/arrays.rs
@@ -1,6 +1,7 @@
 use crate::{
+    array::{ArrayInfo, DynamicArray},
     serde::{de::registration_utils::try_get_registration, TypedReflectDeserializer},
-    ArrayInfo, DynamicArray, TypeRegistry,
+    TypeRegistry,
 };
 use alloc::{string::ToString, vec::Vec};
 use core::{fmt, fmt::Formatter};
@@ -10,7 +11,7 @@ use super::ReflectDeserializerProcessor;
 
 /// A [`Visitor`] for deserializing [`Array`] values.
 ///
-/// [`Array`]: crate::Array
+/// [`Array`]: crate::array::Array
 pub(super) struct ArrayVisitor<'a, P> {
     pub array_info: &'static ArrayInfo,
     pub registry: &'a TypeRegistry,
diff --git a/crates/bevy_reflect/src/serde/de/deserializer.rs b/crates/bevy_reflect/src/serde/de/deserializer.rs
index b9e23e0ff4566..229a49f270f23 100644
--- a/crates/bevy_reflect/src/serde/de/deserializer.rs
+++ b/crates/bevy_reflect/src/serde/de/deserializer.rs
@@ -55,7 +55,7 @@ use super::ReflectDeserializerProcessor;
 /// ```
 /// # use serde::de::DeserializeSeed;
 /// # use bevy_reflect::prelude::*;
-/// # use bevy_reflect::{DynamicStruct, TypeRegistry, serde::ReflectDeserializer};
+/// # use bevy_reflect::{structs::DynamicStruct, TypeRegistry, serde::ReflectDeserializer};
 /// #[derive(Reflect, PartialEq, Debug)]
 /// #[type_path = "my_crate"]
 /// struct MyStruct {
@@ -98,8 +98,8 @@ use super::ReflectDeserializerProcessor;
 /// [`Box<dyn Reflect>`]: crate::Reflect
 /// [`ReflectKind::Opaque`]: crate::ReflectKind::Opaque
 /// [`ReflectDeserialize`]: crate::ReflectDeserialize
-/// [`Box<DynamicStruct>`]: crate::DynamicStruct
-/// [`Box<DynamicList>`]: crate::DynamicList
+/// [`Box<DynamicStruct>`]: crate::structs::DynamicStruct
+/// [`Box<DynamicList>`]: crate::list::DynamicList
 /// [`FromReflect`]: crate::FromReflect
 /// [`ReflectFromReflect`]: crate::ReflectFromReflect
 /// [`with_processor`]: Self::with_processor
@@ -224,7 +224,7 @@ impl<'de, P: ReflectDeserializerProcessor> DeserializeSeed<'de> for ReflectDeser
 /// # use core::any::TypeId;
 /// # use serde::de::DeserializeSeed;
 /// # use bevy_reflect::prelude::*;
-/// # use bevy_reflect::{DynamicStruct, TypeRegistry, serde::TypedReflectDeserializer};
+/// # use bevy_reflect::{structs::DynamicStruct, TypeRegistry, serde::TypedReflectDeserializer};
 /// #[derive(Reflect, PartialEq, Debug)]
 /// struct MyStruct {
 ///   value: i32
@@ -265,8 +265,8 @@ impl<'de, P: ReflectDeserializerProcessor> DeserializeSeed<'de> for ReflectDeser
 /// [`Box<dyn Reflect>`]: crate::Reflect
 /// [`ReflectKind::Opaque`]: crate::ReflectKind::Opaque
 /// [`ReflectDeserialize`]: crate::ReflectDeserialize
-/// [`Box<DynamicStruct>`]: crate::DynamicStruct
-/// [`Box<DynamicList>`]: crate::DynamicList
+/// [`Box<DynamicStruct>`]: crate::structs::DynamicStruct
+/// [`Box<DynamicList>`]: crate::list::DynamicList
 /// [`FromReflect`]: crate::FromReflect
 /// [`ReflectFromReflect`]: crate::ReflectFromReflect
 /// [`with_processor`]: Self::with_processor
diff --git a/crates/bevy_reflect/src/serde/de/enums.rs b/crates/bevy_reflect/src/serde/de/enums.rs
index 21cbf46f9ecb1..25d78d029f403 100644
--- a/crates/bevy_reflect/src/serde/de/enums.rs
+++ b/crates/bevy_reflect/src/serde/de/enums.rs
@@ -1,4 +1,7 @@
 use crate::{
+    enums::{
+        DynamicEnum, DynamicVariant, EnumInfo, StructVariantInfo, TupleVariantInfo, VariantInfo,
+    },
     serde::{
         de::{
             error_utils::make_custom_error,
@@ -9,8 +12,9 @@ use crate::{
         },
         TypedReflectDeserializer,
     },
-    DynamicEnum, DynamicStruct, DynamicTuple, DynamicVariant, EnumInfo, StructVariantInfo,
-    TupleVariantInfo, TypeRegistration, TypeRegistry, VariantInfo,
+    structs::DynamicStruct,
+    tuple::DynamicTuple,
+    TypeRegistration, TypeRegistry,
 };
 use core::{fmt, fmt::Formatter};
 use serde::de::{DeserializeSeed, EnumAccess, Error, MapAccess, SeqAccess, VariantAccess, Visitor};
@@ -19,7 +23,7 @@ use super::ReflectDeserializerProcessor;
 
 /// A [`Visitor`] for deserializing [`Enum`] values.
 ///
-/// [`Enum`]: crate::Enum
+/// [`Enum`]: crate::enums::Enum
 pub(super) struct EnumVisitor<'a, P> {
     pub enum_info: &'static EnumInfo,
     pub registration: &'a TypeRegistration,
diff --git a/crates/bevy_reflect/src/serde/de/lists.rs b/crates/bevy_reflect/src/serde/de/lists.rs
index b85e46874a335..deaa4b3b0ae3e 100644
--- a/crates/bevy_reflect/src/serde/de/lists.rs
+++ b/crates/bevy_reflect/src/serde/de/lists.rs
@@ -1,6 +1,7 @@
 use crate::{
+    list::{DynamicList, ListInfo},
     serde::{de::registration_utils::try_get_registration, TypedReflectDeserializer},
-    DynamicList, ListInfo, TypeRegistry,
+    TypeRegistry,
 };
 use core::{fmt, fmt::Formatter};
 use serde::de::{SeqAccess, Visitor};
@@ -9,7 +10,7 @@ use super::ReflectDeserializerProcessor;
 
 /// A [`Visitor`] for deserializing [`List`] values.
 ///
-/// [`List`]: crate::List
+/// [`List`]: crate::list::List
 pub(super) struct ListVisitor<'a, P> {
     pub list_info: &'static ListInfo,
     pub registry: &'a TypeRegistry,
diff --git a/crates/bevy_reflect/src/serde/de/maps.rs b/crates/bevy_reflect/src/serde/de/maps.rs
index 95b1c1f83e25b..42fc2002f6ee7 100644
--- a/crates/bevy_reflect/src/serde/de/maps.rs
+++ b/crates/bevy_reflect/src/serde/de/maps.rs
@@ -1,6 +1,7 @@
 use crate::{
+    map::{DynamicMap, Map, MapInfo},
     serde::{de::registration_utils::try_get_registration, TypedReflectDeserializer},
-    DynamicMap, Map, MapInfo, TypeRegistry,
+    TypeRegistry,
 };
 use core::{fmt, fmt::Formatter};
 use serde::de::{MapAccess, Visitor};
@@ -9,7 +10,7 @@ use super::ReflectDeserializerProcessor;
 
 /// A [`Visitor`] for deserializing [`Map`] values.
 ///
-/// [`Map`]: crate::Map
+/// [`Map`]: crate::map::Map
 pub(super) struct MapVisitor<'a, P> {
     pub map_info: &'static MapInfo,
     pub registry: &'a TypeRegistry,
diff --git a/crates/bevy_reflect/src/serde/de/mod.rs b/crates/bevy_reflect/src/serde/de/mod.rs
index e82b60bcee5c8..fd0885da58094 100644
--- a/crates/bevy_reflect/src/serde/de/mod.rs
+++ b/crates/bevy_reflect/src/serde/de/mod.rs
@@ -37,12 +37,12 @@ mod tests {
     use bevy_platform::collections::{HashMap, HashSet};
 
     use crate::{
+        enums::DynamicEnum,
         serde::{
             ReflectDeserializer, ReflectDeserializerProcessor, ReflectSerializer,
             TypedReflectDeserializer,
         },
-        DynamicEnum, FromReflect, PartialReflect, Reflect, ReflectDeserialize, TypeRegistration,
-        TypeRegistry,
+        FromReflect, PartialReflect, Reflect, ReflectDeserialize, TypeRegistration, TypeRegistry,
     };
 
     #[derive(Reflect, Debug, PartialEq)]
diff --git a/crates/bevy_reflect/src/serde/de/options.rs b/crates/bevy_reflect/src/serde/de/options.rs
index f347c4a67d8e3..11fc34b3b9dab 100644
--- a/crates/bevy_reflect/src/serde/de/options.rs
+++ b/crates/bevy_reflect/src/serde/de/options.rs
@@ -1,9 +1,11 @@
 use crate::{
+    enums::{DynamicEnum, EnumInfo, VariantInfo},
     serde::{
         de::{error_utils::make_custom_error, registration_utils::try_get_registration},
         TypedReflectDeserializer,
     },
-    DynamicEnum, DynamicTuple, EnumInfo, TypeRegistry, VariantInfo,
+    tuple::DynamicTuple,
+    TypeRegistry,
 };
 use core::{fmt, fmt::Formatter};
 use serde::de::{DeserializeSeed, Error, Visitor};
diff --git a/crates/bevy_reflect/src/serde/de/sets.rs b/crates/bevy_reflect/src/serde/de/sets.rs
index ed1a469df3d7d..682b958ff6489 100644
--- a/crates/bevy_reflect/src/serde/de/sets.rs
+++ b/crates/bevy_reflect/src/serde/de/sets.rs
@@ -1,6 +1,7 @@
 use crate::{
     serde::{de::registration_utils::try_get_registration, TypedReflectDeserializer},
-    DynamicSet, Set, SetInfo, TypeRegistry,
+    set::{DynamicSet, Set, SetInfo},
+    TypeRegistry,
 };
 use core::{fmt, fmt::Formatter};
 use serde::de::{SeqAccess, Visitor};
@@ -9,7 +10,7 @@ use super::ReflectDeserializerProcessor;
 
 /// A [`Visitor`] for deserializing [`Set`] values.
 ///
-/// [`Set`]: crate::Set
+/// [`Set`]: crate::set::Set
 pub(super) struct SetVisitor<'a, P> {
     pub set_info: &'static SetInfo,
     pub registry: &'a TypeRegistry,
diff --git a/crates/bevy_reflect/src/serde/de/struct_utils.rs b/crates/bevy_reflect/src/serde/de/struct_utils.rs
index 9ac56d9a4a88b..1a51f19361c94 100644
--- a/crates/bevy_reflect/src/serde/de/struct_utils.rs
+++ b/crates/bevy_reflect/src/serde/de/struct_utils.rs
@@ -1,4 +1,5 @@
 use crate::{
+    enums::StructVariantInfo,
     serde::{
         de::{
             error_utils::make_custom_error,
@@ -7,7 +8,8 @@ use crate::{
         },
         SerializationData, TypedReflectDeserializer,
     },
-    DynamicStruct, NamedField, StructInfo, StructVariantInfo, TypeRegistration, TypeRegistry,
+    structs::{DynamicStruct, StructInfo},
+    NamedField, TypeRegistration, TypeRegistry,
 };
 use alloc::string::ToString;
 use core::slice::Iter;
diff --git a/crates/bevy_reflect/src/serde/de/structs.rs b/crates/bevy_reflect/src/serde/de/structs.rs
index 0135e96358580..79ae3bf48d9fd 100644
--- a/crates/bevy_reflect/src/serde/de/structs.rs
+++ b/crates/bevy_reflect/src/serde/de/structs.rs
@@ -1,6 +1,7 @@
 use crate::{
     serde::de::struct_utils::{visit_struct, visit_struct_seq},
-    DynamicStruct, StructInfo, TypeRegistration, TypeRegistry,
+    structs::{DynamicStruct, StructInfo},
+    TypeRegistration, TypeRegistry,
 };
 use core::{fmt, fmt::Formatter};
 use serde::de::{MapAccess, SeqAccess, Visitor};
@@ -9,7 +10,7 @@ use super::ReflectDeserializerProcessor;
 
 /// A [`Visitor`] for deserializing [`Struct`] values.
 ///
-/// [`Struct`]: crate::Struct
+/// [`Struct`]: crate::structs::Struct
 pub(super) struct StructVisitor<'a, P> {
     pub struct_info: &'static StructInfo,
     pub registration: &'a TypeRegistration,
diff --git a/crates/bevy_reflect/src/serde/de/tuple_structs.rs b/crates/bevy_reflect/src/serde/de/tuple_structs.rs
index af33b8d0b3c33..7c94d1368ff64 100644
--- a/crates/bevy_reflect/src/serde/de/tuple_structs.rs
+++ b/crates/bevy_reflect/src/serde/de/tuple_structs.rs
@@ -1,6 +1,7 @@
 use crate::{
     serde::{de::tuple_utils::visit_tuple, SerializationData},
-    DynamicTupleStruct, TupleStructInfo, TypeRegistration, TypeRegistry,
+    tuple_struct::{DynamicTupleStruct, TupleStructInfo},
+    TypeRegistration, TypeRegistry,
 };
 use core::{fmt, fmt::Formatter};
 use serde::de::{DeserializeSeed, SeqAccess, Visitor};
@@ -11,7 +12,7 @@ use super::ReflectDeserializerProcessor;
 
 /// A [`Visitor`] for deserializing [`TupleStruct`] values.
 ///
-/// [`TupleStruct`]: crate::TupleStruct
+/// [`TupleStruct`]: crate::tuple_struct::TupleStruct
 pub(super) struct TupleStructVisitor<'a, P> {
     pub tuple_struct_info: &'static TupleStructInfo,
     pub registration: &'a TypeRegistration,
diff --git a/crates/bevy_reflect/src/serde/de/tuple_utils.rs b/crates/bevy_reflect/src/serde/de/tuple_utils.rs
index 13a65b4dd64ec..19f24d2b73744 100644
--- a/crates/bevy_reflect/src/serde/de/tuple_utils.rs
+++ b/crates/bevy_reflect/src/serde/de/tuple_utils.rs
@@ -1,10 +1,12 @@
 use crate::{
+    enums::TupleVariantInfo,
     serde::{
         de::{error_utils::make_custom_error, registration_utils::try_get_registration},
         SerializationData, TypedReflectDeserializer,
     },
-    DynamicTuple, TupleInfo, TupleStructInfo, TupleVariantInfo, TypeRegistration, TypeRegistry,
-    UnnamedField,
+    tuple::{DynamicTuple, TupleInfo},
+    tuple_struct::TupleStructInfo,
+    TypeRegistration, TypeRegistry, UnnamedField,
 };
 use alloc::string::ToString;
 use serde::de::{Error, SeqAccess};
diff --git a/crates/bevy_reflect/src/serde/de/tuples.rs b/crates/bevy_reflect/src/serde/de/tuples.rs
index 87b9fc81c9439..fd6f73e48703b 100644
--- a/crates/bevy_reflect/src/serde/de/tuples.rs
+++ b/crates/bevy_reflect/src/serde/de/tuples.rs
@@ -1,5 +1,7 @@
 use crate::{
-    serde::de::tuple_utils::visit_tuple, DynamicTuple, TupleInfo, TypeRegistration, TypeRegistry,
+    serde::de::tuple_utils::visit_tuple,
+    tuple::{DynamicTuple, TupleInfo},
+    TypeRegistration, TypeRegistry,
 };
 use core::{fmt, fmt::Formatter};
 use serde::de::{SeqAccess, Visitor};
@@ -8,7 +10,7 @@ use super::ReflectDeserializerProcessor;
 
 /// A [`Visitor`] for deserializing [`Tuple`] values.
 ///
-/// [`Tuple`]: crate::Tuple
+/// [`Tuple`]: crate::tuple::Tuple
 pub(super) struct TupleVisitor<'a, P> {
     pub tuple_info: &'static TupleInfo,
     pub registration: &'a TypeRegistration,
diff --git a/crates/bevy_reflect/src/serde/mod.rs b/crates/bevy_reflect/src/serde/mod.rs
index 2ee47d4a7f5d9..5dec549160bdc 100644
--- a/crates/bevy_reflect/src/serde/mod.rs
+++ b/crates/bevy_reflect/src/serde/mod.rs
@@ -12,8 +12,10 @@ pub use type_data::*;
 mod tests {
     use super::*;
     use crate::{
-        type_registry::TypeRegistry, DynamicStruct, DynamicTupleStruct, FromReflect,
-        PartialReflect, Reflect, Struct,
+        structs::{DynamicStruct, Struct},
+        tuple_struct::DynamicTupleStruct,
+        type_registry::TypeRegistry,
+        FromReflect, PartialReflect, Reflect,
     };
     use serde::de::DeserializeSeed;
 
diff --git a/crates/bevy_reflect/src/serde/ser/arrays.rs b/crates/bevy_reflect/src/serde/ser/arrays.rs
index 9d565344aeb44..fb3786d00de85 100644
--- a/crates/bevy_reflect/src/serde/ser/arrays.rs
+++ b/crates/bevy_reflect/src/serde/ser/arrays.rs
@@ -1,4 +1,4 @@
-use crate::{serde::TypedReflectSerializer, Array, TypeRegistry};
+use crate::{array::Array, serde::TypedReflectSerializer, TypeRegistry};
 use serde::{ser::SerializeTuple, Serialize};
 
 use super::ReflectSerializerProcessor;
diff --git a/crates/bevy_reflect/src/serde/ser/enums.rs b/crates/bevy_reflect/src/serde/ser/enums.rs
index 86c4360ce037b..6eba01e44ede1 100644
--- a/crates/bevy_reflect/src/serde/ser/enums.rs
+++ b/crates/bevy_reflect/src/serde/ser/enums.rs
@@ -1,6 +1,7 @@
 use crate::{
+    enums::{Enum, VariantInfo, VariantType},
     serde::{ser::error_utils::make_custom_error, TypedReflectSerializer},
-    Enum, TypeInfo, TypeRegistry, VariantInfo, VariantType,
+    TypeInfo, TypeRegistry,
 };
 use serde::{
     ser::{SerializeStructVariant, SerializeTupleVariant},
diff --git a/crates/bevy_reflect/src/serde/ser/lists.rs b/crates/bevy_reflect/src/serde/ser/lists.rs
index 4c3fb6b33dd25..d96317a247814 100644
--- a/crates/bevy_reflect/src/serde/ser/lists.rs
+++ b/crates/bevy_reflect/src/serde/ser/lists.rs
@@ -1,4 +1,4 @@
-use crate::{serde::TypedReflectSerializer, List, TypeRegistry};
+use crate::{list::List, serde::TypedReflectSerializer, TypeRegistry};
 use serde::{ser::SerializeSeq, Serialize};
 
 use super::ReflectSerializerProcessor;
diff --git a/crates/bevy_reflect/src/serde/ser/maps.rs b/crates/bevy_reflect/src/serde/ser/maps.rs
index c1a8c287c1b3f..ac0e43a150159 100644
--- a/crates/bevy_reflect/src/serde/ser/maps.rs
+++ b/crates/bevy_reflect/src/serde/ser/maps.rs
@@ -1,4 +1,4 @@
-use crate::{serde::TypedReflectSerializer, Map, TypeRegistry};
+use crate::{map::Map, serde::TypedReflectSerializer, TypeRegistry};
 use serde::{ser::SerializeMap, Serialize};
 
 use super::ReflectSerializerProcessor;
diff --git a/crates/bevy_reflect/src/serde/ser/mod.rs b/crates/bevy_reflect/src/serde/ser/mod.rs
index 25399e1d711e5..c56e96d66b650 100644
--- a/crates/bevy_reflect/src/serde/ser/mod.rs
+++ b/crates/bevy_reflect/src/serde/ser/mod.rs
@@ -22,7 +22,8 @@ mod tuples;
 mod tests {
     use crate::{
         serde::{ReflectSerializer, ReflectSerializerProcessor},
-        PartialReflect, Reflect, ReflectSerialize, Struct, TypeRegistry,
+        structs::Struct,
+        PartialReflect, Reflect, ReflectSerialize, TypeRegistry,
     };
     #[cfg(feature = "functions")]
     use alloc::boxed::Box;
diff --git a/crates/bevy_reflect/src/serde/ser/sets.rs b/crates/bevy_reflect/src/serde/ser/sets.rs
index 34e8899d58c95..d4f5a2d7666fc 100644
--- a/crates/bevy_reflect/src/serde/ser/sets.rs
+++ b/crates/bevy_reflect/src/serde/ser/sets.rs
@@ -1,4 +1,4 @@
-use crate::{serde::TypedReflectSerializer, Set, TypeRegistry};
+use crate::{serde::TypedReflectSerializer, set::Set, TypeRegistry};
 use serde::{ser::SerializeSeq, Serialize};
 
 use super::ReflectSerializerProcessor;
diff --git a/crates/bevy_reflect/src/serde/ser/structs.rs b/crates/bevy_reflect/src/serde/ser/structs.rs
index 828eb3e6cb829..2797586a423b1 100644
--- a/crates/bevy_reflect/src/serde/ser/structs.rs
+++ b/crates/bevy_reflect/src/serde/ser/structs.rs
@@ -1,6 +1,7 @@
 use crate::{
     serde::{ser::error_utils::make_custom_error, SerializationData, TypedReflectSerializer},
-    Struct, TypeInfo, TypeRegistry,
+    structs::Struct,
+    TypeInfo, TypeRegistry,
 };
 use serde::{ser::SerializeStruct, Serialize};
 
diff --git a/crates/bevy_reflect/src/serde/ser/tuple_structs.rs b/crates/bevy_reflect/src/serde/ser/tuple_structs.rs
index 00554c0a86694..850b80e253c02 100644
--- a/crates/bevy_reflect/src/serde/ser/tuple_structs.rs
+++ b/crates/bevy_reflect/src/serde/ser/tuple_structs.rs
@@ -1,6 +1,7 @@
 use crate::{
     serde::{ser::error_utils::make_custom_error, SerializationData, TypedReflectSerializer},
-    TupleStruct, TypeInfo, TypeRegistry,
+    tuple_struct::TupleStruct,
+    TypeInfo, TypeRegistry,
 };
 use serde::{ser::SerializeTupleStruct, Serialize};
 
diff --git a/crates/bevy_reflect/src/serde/ser/tuples.rs b/crates/bevy_reflect/src/serde/ser/tuples.rs
index 195d1e492d76b..6d6d1b615f988 100644
--- a/crates/bevy_reflect/src/serde/ser/tuples.rs
+++ b/crates/bevy_reflect/src/serde/ser/tuples.rs
@@ -1,4 +1,4 @@
-use crate::{serde::TypedReflectSerializer, Tuple, TypeRegistry};
+use crate::{serde::TypedReflectSerializer, tuple::Tuple, TypeRegistry};
 use serde::{ser::SerializeTuple, Serialize};
 
 use super::ReflectSerializerProcessor;
diff --git a/crates/bevy_reflect/src/serde/type_data.rs b/crates/bevy_reflect/src/serde/type_data.rs
index 9bb3e134ac6bc..cb398bab22c19 100644
--- a/crates/bevy_reflect/src/serde/type_data.rs
+++ b/crates/bevy_reflect/src/serde/type_data.rs
@@ -28,7 +28,7 @@ impl SerializationData {
     ///
     /// ```
     /// # use core::any::TypeId;
-    /// # use bevy_reflect::{Reflect, Struct, TypeRegistry, serde::SerializationData};
+    /// # use bevy_reflect::{Reflect, structs::Struct, TypeRegistry, serde::SerializationData};
     /// #[derive(Reflect)]
     /// struct MyStruct {
     ///   serialize_me: i32,
@@ -68,7 +68,7 @@ impl SerializationData {
     ///
     /// ```
     /// # use core::any::TypeId;
-    /// # use bevy_reflect::{Reflect, Struct, TypeRegistry, serde::SerializationData};
+    /// # use bevy_reflect::{Reflect, structs::Struct, TypeRegistry, serde::SerializationData};
     /// #[derive(Reflect)]
     /// struct MyStruct {
     ///   serialize_me: i32,
diff --git a/crates/bevy_reflect/src/set.rs b/crates/bevy_reflect/src/set.rs
index f5a63264587d8..8d1fc851dbd86 100644
--- a/crates/bevy_reflect/src/set.rs
+++ b/crates/bevy_reflect/src/set.rs
@@ -1,3 +1,6 @@
+//! A trait used to power [set-like] operations via reflection.
+//!
+//! [set-like]: https://doc.rust-lang.org/stable/std/collections/struct.HashSet.html
 use alloc::{boxed::Box, format, vec::Vec};
 use core::fmt::{Debug, Formatter};
 
@@ -29,7 +32,7 @@ use crate::{
 /// # Example
 ///
 /// ```
-/// use bevy_reflect::{PartialReflect, Set};
+/// use bevy_reflect::{PartialReflect, set::Set};
 /// use std::collections::HashSet;
 ///
 ///
@@ -488,7 +491,7 @@ pub fn set_try_apply<S: Set>(a: &mut S, b: &dyn PartialReflect) -> Result<(), Ap
 
 #[cfg(test)]
 mod tests {
-    use crate::{PartialReflect, Set};
+    use crate::{set::Set, PartialReflect};
 
     use super::DynamicSet;
     use alloc::string::{String, ToString};
diff --git a/crates/bevy_reflect/src/struct_trait.rs b/crates/bevy_reflect/src/structs.rs
similarity index 98%
rename from crates/bevy_reflect/src/struct_trait.rs
rename to crates/bevy_reflect/src/structs.rs
index a6aa79b1f0c2d..75bd77848394a 100644
--- a/crates/bevy_reflect/src/struct_trait.rs
+++ b/crates/bevy_reflect/src/structs.rs
@@ -1,3 +1,6 @@
+//! Traits and types used to power [struct-like] operations via reflection.
+//!
+//! [struct-like]: https://doc.rust-lang.org/book/ch05-01-defining-structs.html
 use crate::generics::impl_generic_info_methods;
 use crate::{
     attributes::{impl_custom_attribute_methods, CustomAttributes},
@@ -26,7 +29,7 @@ use core::{
 /// # Example
 ///
 /// ```
-/// use bevy_reflect::{PartialReflect, Reflect, Struct};
+/// use bevy_reflect::{PartialReflect, Reflect, structs::Struct};
 ///
 /// #[derive(Reflect)]
 /// struct Foo {
@@ -225,7 +228,7 @@ impl<'a> ExactSizeIterator for FieldIter<'a> {}
 /// # Example
 ///
 /// ```
-/// use bevy_reflect::{GetField, Reflect};
+/// use bevy_reflect::{structs::GetField, Reflect};
 ///
 /// #[derive(Reflect)]
 /// struct Foo {
@@ -573,7 +576,7 @@ pub fn struct_debug(dyn_struct: &dyn Struct, f: &mut Formatter<'_>) -> core::fmt
 
 #[cfg(test)]
 mod tests {
-    use crate::*;
+    use crate::{structs::*, *};
     #[derive(Reflect, Default)]
     struct MyStruct {
         a: (),
diff --git a/crates/bevy_reflect/src/tuple.rs b/crates/bevy_reflect/src/tuple.rs
index aa9530bddfaf5..11e0d9de2a175 100644
--- a/crates/bevy_reflect/src/tuple.rs
+++ b/crates/bevy_reflect/src/tuple.rs
@@ -1,3 +1,6 @@
+//! Traits and types used to power [tuple-like] operations via reflection.
+//!
+//! [tuple-like]: https://doc.rust-lang.org/book/ch03-02-data-types.html#the-tuple-type
 use bevy_reflect_derive::impl_type_path;
 use variadics_please::all_tuples;
 
@@ -26,7 +29,7 @@ use core::{
 /// # Example
 ///
 /// ```
-/// use bevy_reflect::{PartialReflect, Tuple};
+/// use bevy_reflect::{PartialReflect, tuple::Tuple};
 ///
 /// let foo = (123_u32, true);
 /// assert_eq!(foo.field_len(), 2);
@@ -108,7 +111,7 @@ impl<'a> ExactSizeIterator for TupleFieldIter<'a> {}
 /// # Example
 ///
 /// ```
-/// use bevy_reflect::GetTupleField;
+/// use bevy_reflect::tuple::GetTupleField;
 ///
 /// # fn main() {
 /// let foo = ("blue".to_string(), 42_i32);
@@ -555,15 +558,15 @@ macro_rules! impl_reflect_tuple {
             }
 
             fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool> {
-                crate::tuple_partial_eq(self, value)
+                crate::tuple::tuple_partial_eq(self, value)
             }
 
             fn apply(&mut self, value: &dyn PartialReflect) {
-                crate::tuple_apply(self, value);
+                crate::tuple::tuple_apply(self, value);
             }
 
             fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError> {
-                crate::tuple_try_apply(self, value)
+                crate::tuple::tuple_try_apply(self, value)
             }
 
             fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError> {
diff --git a/crates/bevy_reflect/src/tuple_struct.rs b/crates/bevy_reflect/src/tuple_struct.rs
index 8b5ea80492721..5e289f0bec870 100644
--- a/crates/bevy_reflect/src/tuple_struct.rs
+++ b/crates/bevy_reflect/src/tuple_struct.rs
@@ -1,11 +1,15 @@
+//! Traits and types used to power [tuple-struct-like] operations via reflection.
+//!
+//! [tuple-struct-like]: https://doc.rust-lang.org/book/ch05-01-defining-structs.html#using-tuple-structs-without-named-fields-to-create-different-types
 use bevy_reflect_derive::impl_type_path;
 
 use crate::generics::impl_generic_info_methods;
 use crate::{
     attributes::{impl_custom_attribute_methods, CustomAttributes},
+    tuple::{DynamicTuple, Tuple},
     type_info::impl_type_methods,
-    ApplyError, DynamicTuple, Generics, PartialReflect, Reflect, ReflectKind, ReflectMut,
-    ReflectOwned, ReflectRef, Tuple, Type, TypeInfo, TypePath, UnnamedField,
+    ApplyError, Generics, PartialReflect, Reflect, ReflectKind, ReflectMut, ReflectOwned,
+    ReflectRef, Type, TypeInfo, TypePath, UnnamedField,
 };
 use alloc::{boxed::Box, vec::Vec};
 use bevy_platform::sync::Arc;
@@ -25,7 +29,7 @@ use core::{
 /// # Example
 ///
 /// ```
-/// use bevy_reflect::{PartialReflect, Reflect, TupleStruct};
+/// use bevy_reflect::{PartialReflect, Reflect, tuple_struct::TupleStruct};
 ///
 /// #[derive(Reflect)]
 /// struct Foo(u32);
@@ -178,7 +182,7 @@ impl<'a> ExactSizeIterator for TupleStructFieldIter<'a> {}
 /// # Example
 ///
 /// ```
-/// use bevy_reflect::{GetTupleStructField, Reflect};
+/// use bevy_reflect::{tuple_struct::GetTupleStructField, Reflect};
 ///
 /// #[derive(Reflect)]
 /// struct Foo(String);
@@ -483,7 +487,8 @@ pub fn tuple_struct_debug(
 
 #[cfg(test)]
 mod tests {
-    use crate::*;
+    use super::TupleStruct;
+    use crate::Reflect;
     #[derive(Reflect)]
     struct Ts(u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8, u8);
     #[test]
diff --git a/crates/bevy_reflect/src/type_info.rs b/crates/bevy_reflect/src/type_info.rs
index d511249a36240..99c768c092a40 100644
--- a/crates/bevy_reflect/src/type_info.rs
+++ b/crates/bevy_reflect/src/type_info.rs
@@ -1,7 +1,13 @@
 use crate::{
-    ArrayInfo, DynamicArray, DynamicEnum, DynamicList, DynamicMap, DynamicStruct, DynamicTuple,
-    DynamicTupleStruct, EnumInfo, Generics, ListInfo, MapInfo, PartialReflect, Reflect,
-    ReflectKind, SetInfo, StructInfo, TupleInfo, TupleStructInfo, TypePath, TypePathTable,
+    array::{ArrayInfo, DynamicArray},
+    enums::{DynamicEnum, EnumInfo},
+    list::{DynamicList, ListInfo},
+    map::{DynamicMap, MapInfo},
+    set::SetInfo,
+    structs::{DynamicStruct, StructInfo},
+    tuple::{DynamicTuple, TupleInfo},
+    tuple_struct::{DynamicTupleStruct, TupleStructInfo},
+    Generics, PartialReflect, Reflect, ReflectKind, TypePath, TypePathTable,
 };
 use core::{
     any::{Any, TypeId},
@@ -33,7 +39,7 @@ use thiserror::Error;
 ///
 /// ```
 /// # use core::any::Any;
-/// # use bevy_reflect::{DynamicTypePath, NamedField, PartialReflect, Reflect, ReflectMut, ReflectOwned, ReflectRef, StructInfo, TypeInfo, TypePath, OpaqueInfo, ApplyError};
+/// # use bevy_reflect::{DynamicTypePath, NamedField, PartialReflect, Reflect, ReflectMut, ReflectOwned, ReflectRef, structs::StructInfo, TypeInfo, TypePath, OpaqueInfo, ApplyError};
 /// # use bevy_reflect::utility::NonGenericTypeInfoCell;
 /// use bevy_reflect::Typed;
 ///
@@ -203,35 +209,35 @@ pub enum TypeInfoError {
 pub enum TypeInfo {
     /// Type information for a [struct-like] type.
     ///
-    /// [struct-like]: crate::Struct
+    /// [struct-like]: crate::structs::Struct
     Struct(StructInfo),
     /// Type information for a [tuple-struct-like] type.
     ///
-    /// [tuple-struct-like]: crate::TupleStruct
+    /// [tuple-struct-like]: crate::tuple_struct::TupleStruct
     TupleStruct(TupleStructInfo),
     /// Type information for a [tuple-like] type.
     ///
-    /// [tuple-like]: crate::Tuple
+    /// [tuple-like]: crate::tuple::Tuple
     Tuple(TupleInfo),
     /// Type information for a [list-like] type.
     ///
-    /// [list-like]: crate::List
+    /// [list-like]: crate::list::List
     List(ListInfo),
     /// Type information for an [array-like] type.
     ///
-    /// [array-like]: crate::Array
+    /// [array-like]: crate::array::Array
     Array(ArrayInfo),
     /// Type information for a [map-like] type.
     ///
-    /// [map-like]: crate::Map
+    /// [map-like]: crate::map::Map
     Map(MapInfo),
     /// Type information for a [set-like] type.
     ///
-    /// [set-like]: crate::Set
+    /// [set-like]: crate::set::Set
     Set(SetInfo),
     /// Type information for an [enum-like] type.
     ///
-    /// [enum-like]: crate::Enum
+    /// [enum-like]: crate::enums::Enum
     Enum(EnumInfo),
     /// Type information for an opaque type - see the [`OpaqueInfo`] docs for
     /// a discussion of opaque types.
diff --git a/crates/bevy_reflect/src/utility.rs b/crates/bevy_reflect/src/utility.rs
index 42d8d8be79fb7..65a45cf797aa6 100644
--- a/crates/bevy_reflect/src/utility.rs
+++ b/crates/bevy_reflect/src/utility.rs
@@ -56,7 +56,7 @@ mod sealed {
 ///
 /// ```
 /// # use core::any::Any;
-/// # use bevy_reflect::{DynamicTypePath, NamedField, PartialReflect, Reflect, ReflectMut, ReflectOwned, ReflectRef, StructInfo, Typed, TypeInfo, TypePath, ApplyError};
+/// # use bevy_reflect::{DynamicTypePath, NamedField, PartialReflect, Reflect, ReflectMut, ReflectOwned, ReflectRef, structs::StructInfo, Typed, TypeInfo, TypePath, ApplyError};
 /// use bevy_reflect::utility::NonGenericTypeInfoCell;
 ///
 /// struct Foo {
@@ -144,7 +144,7 @@ impl<T: TypedProperty> Default for NonGenericTypeCell<T> {
 ///
 /// ```
 /// # use core::any::Any;
-/// # use bevy_reflect::{DynamicTypePath, PartialReflect, Reflect, ReflectMut, ReflectOwned, ReflectRef, TupleStructInfo, Typed, TypeInfo, TypePath, UnnamedField, ApplyError, Generics, TypeParamInfo};
+/// # use bevy_reflect::{DynamicTypePath, PartialReflect, Reflect, ReflectMut, ReflectOwned, ReflectRef, tuple_struct::TupleStructInfo, Typed, TypeInfo, TypePath, UnnamedField, ApplyError, Generics, TypeParamInfo};
 /// use bevy_reflect::utility::GenericTypeInfoCell;
 ///
 /// struct Foo<T>(T);
diff --git a/crates/bevy_remote/src/builtin_methods.rs b/crates/bevy_remote/src/builtin_methods.rs
index 3c4c97d1388d3..7e6f7e5115775 100644
--- a/crates/bevy_remote/src/builtin_methods.rs
+++ b/crates/bevy_remote/src/builtin_methods.rs
@@ -18,7 +18,8 @@ use bevy_log::warn_once;
 use bevy_platform::collections::HashMap;
 use bevy_reflect::{
     serde::{ReflectSerializer, TypedReflectDeserializer},
-    DynamicStruct, GetPath, PartialReflect, TypeRegistration, TypeRegistry,
+    structs::DynamicStruct,
+    GetPath, PartialReflect, TypeRegistration, TypeRegistry,
 };
 use serde::{de::DeserializeSeed as _, de::IntoDeserializer, Deserialize, Serialize};
 use serde_json::{Map, Value};
diff --git a/crates/bevy_remote/src/schemas/json_schema.rs b/crates/bevy_remote/src/schemas/json_schema.rs
index 4e56625bc8eff..ca0865b62259c 100644
--- a/crates/bevy_remote/src/schemas/json_schema.rs
+++ b/crates/bevy_remote/src/schemas/json_schema.rs
@@ -3,8 +3,8 @@
 use alloc::borrow::Cow;
 use bevy_platform::collections::HashMap;
 use bevy_reflect::{
-    GetTypeRegistration, NamedField, OpaqueInfo, TypeInfo, TypeRegistration, TypeRegistry,
-    VariantInfo,
+    enums::VariantInfo, GetTypeRegistration, NamedField, OpaqueInfo, TypeInfo, TypeRegistration,
+    TypeRegistry,
 };
 use core::any::TypeId;
 use serde::{Deserialize, Serialize};
diff --git a/examples/reflection/dynamic_types.rs b/examples/reflection/dynamic_types.rs
index 772ffe1dd24dd..e5ba6b089f34f 100644
--- a/examples/reflection/dynamic_types.rs
+++ b/examples/reflection/dynamic_types.rs
@@ -1,10 +1,18 @@
 //! This example demonstrates the use of dynamic types in Bevy's reflection system.
 
 use bevy::reflect::{
-    reflect_trait, serde::TypedReflectDeserializer, std_traits::ReflectDefault, DynamicArray,
-    DynamicEnum, DynamicList, DynamicMap, DynamicSet, DynamicStruct, DynamicTuple,
-    DynamicTupleStruct, DynamicVariant, FromReflect, PartialReflect, Reflect, ReflectFromReflect,
-    Set, TypeRegistry, Typed,
+    array::DynamicArray,
+    enums::{DynamicEnum, DynamicVariant},
+    list::DynamicList,
+    map::DynamicMap,
+    reflect_trait,
+    serde::TypedReflectDeserializer,
+    set::{DynamicSet, Set},
+    std_traits::ReflectDefault,
+    structs::DynamicStruct,
+    tuple::DynamicTuple,
+    tuple_struct::DynamicTupleStruct,
+    FromReflect, PartialReflect, Reflect, ReflectFromReflect, TypeRegistry, Typed,
 };
 use serde::de::DeserializeSeed;
 use std::collections::{HashMap, HashSet};
diff --git a/examples/reflection/reflection.rs b/examples/reflection/reflection.rs
index 9c7350cb5835d..2258236a54b02 100644
--- a/examples/reflection/reflection.rs
+++ b/examples/reflection/reflection.rs
@@ -8,7 +8,8 @@ use bevy::{
     prelude::*,
     reflect::{
         serde::{ReflectDeserializer, ReflectSerializer},
-        DynamicStruct, PartialReflect,
+        structs::DynamicStruct,
+        PartialReflect,
     },
 };
 use serde::de::DeserializeSeed;
diff --git a/examples/reflection/reflection_types.rs b/examples/reflection/reflection_types.rs
index 63594ec8acd38..6f7f407d10f5f 100644
--- a/examples/reflection/reflection_types.rs
+++ b/examples/reflection/reflection_types.rs
@@ -4,7 +4,7 @@
 use bevy::{
     platform::collections::HashMap,
     prelude::*,
-    reflect::{DynamicList, PartialReflect, ReflectRef},
+    reflect::{list::DynamicList, PartialReflect, ReflectRef},
 };
 use serde::{Deserialize, Serialize};
 
diff --git a/release-content/migration-guides/bevy_reflect_reorganization.md b/release-content/migration-guides/bevy_reflect_reorganization.md
new file mode 100644
index 0000000000000..2c1da5bcba5df
--- /dev/null
+++ b/release-content/migration-guides/bevy_reflect_reorganization.md
@@ -0,0 +1,21 @@
+---
+title: "`bevy_reflect` reorganized to de-clutter the crate root"
+pull_requests: [22342]
+---
+
+`bevy_reflect` has undergone a large reorganization. Many modules have been exposed in the crate root, each containing items relevant to their "kind" of reflected type:
+
+* `array`
+* `enums`
+* `list`
+* `map`
+* `set`
+* `structs`
+* `tuple`
+* `tuple_struct`
+
+For example, the `structs` module now contains the `Struct` trait, as well as related items like `DynamicStruct` or `StructInfo`.
+
+This change was made to de-clutter the crate root of `bevy_reflect`, hopefully making it easier to find what traits and types you need for your use of reflection.
+
+Migrating should only require editing your `use` statements. The Rust compiler will give hints at the new type paths, should you need any assistance.