diff --git a/codec/codec.go b/codec/codec.go
index 3d9cfd771bc0..026d3e4cd760 100644
--- a/codec/codec.go
+++ b/codec/codec.go
@@ -72,7 +72,7 @@ type (
 		// MarshalInterface is a helper method which will wrap `i` into `Any` for correct
 		// binary interface (de)serialization.
 		MarshalInterface(i proto.Message) ([]byte, error)
-		// UnmarshalInterface is a helper method which will parse binary enoded data
+		// UnmarshalInterface is a helper method which will parse binary encoded data
 		// into `Any` and unpack any into the `ptr`. It fails if the target interface type
 		// is not registered in codec, or is not compatible with the serialized data
 		UnmarshalInterface(bz []byte, ptr interface{}) error
@@ -88,7 +88,7 @@ type (
 		// MarshalInterfaceJSON is a helper method which will wrap `i` into `Any` for correct
 		// JSON interface (de)serialization.
 		MarshalInterfaceJSON(i proto.Message) ([]byte, error)
-		// UnmarshalInterfaceJSON is a helper method which will parse JSON enoded data
+		// UnmarshalInterfaceJSON is a helper method which will parse JSON encoded data
 		// into `Any` and unpack any into the `ptr`. It fails if the target interface type
 		// is not registered in codec, or is not compatible with the serialized data
 		UnmarshalInterfaceJSON(bz []byte, ptr interface{}) error
diff --git a/docs/architecture/adr-033-protobuf-inter-module-comm.md b/docs/architecture/adr-033-protobuf-inter-module-comm.md
index 4f2769e6770f..83bb4dcb242f 100644
--- a/docs/architecture/adr-033-protobuf-inter-module-comm.md
+++ b/docs/architecture/adr-033-protobuf-inter-module-comm.md
@@ -378,7 +378,7 @@ replacing `Keeper` interfaces altogether.
 
 * an alternative to keepers which can more easily lead to stable inter-module interfaces
 * proper inter-module OCAPs
-* improved module developer DevX, as commented on by several particpants on
+* improved module developer DevX, as commented on by several participants on
     [Architecture Review Call, Dec 3](https://hackmd.io/E0wxxOvRQ5qVmTf6N_k84Q)
 * lays the groundwork for what can be a greatly simplified `app.go`
 * router can be setup to enforce atomic transactions for module-to-module calls
diff --git a/docs/build/building-modules/00-intro.md b/docs/build/building-modules/00-intro.md
index 10b21db77e18..b301e92ae318 100644
--- a/docs/build/building-modules/00-intro.md
+++ b/docs/build/building-modules/00-intro.md
@@ -63,7 +63,7 @@ While there are no definitive guidelines for writing modules, here are some impo
 The SDK provides a set of APIs that a module can implement, and a set of services that a module can use.
 Those APIs are defined in the `cosmossdk.io/core/appmodule` package, and are used to defined the module capabilities, which is used by `runtime` during the wiring of the application. 
 
-Whenever possible, a module should strive to use only the core APIs (`cosmossdk.io/core`) and not import the `github.com/cosmos/cosmos-sdk` module. This makes modules reusable accross SDK versions and reduces the risk of breaking changes.
+Whenever possible, a module should strive to use only the core APIs (`cosmossdk.io/core`) and not import the `github.com/cosmos/cosmos-sdk` module. This makes modules reusable across SDK versions and reduces the risk of breaking changes.
 
 Learn more about the core APIs for modules [here](../../learn/advanced/02-core.md).
 
diff --git a/docs/learn/beginner/00-app-anatomy.md b/docs/learn/beginner/00-app-anatomy.md
index 056a107f2190..dd771bec769e 100644
--- a/docs/learn/beginner/00-app-anatomy.md
+++ b/docs/learn/beginner/00-app-anatomy.md
@@ -59,7 +59,7 @@ In general, the core of the state-machine is defined in a file called `app.go`.
 
 The first thing defined in `app.go` is the `type` of the application. It is generally comprised of the following parts:
 
-* **Embeding [runtime.App](../../build/building-apps/00-runtime.md)** The runtime package manages the application's core components and modules through dependency injection. It provides declarative configuration for module management, state storage, and ABCI handling.
+* **Embedding [runtime.App](../../build/building-apps/00-runtime.md)** The runtime package manages the application's core components and modules through dependency injection. It provides declarative configuration for module management, state storage, and ABCI handling.
     * `Runtime` wraps `baseapp`, meaning when a transaction is relayed by CometBFT to the application, `app` uses `runtime`'s methods to route them to the appropriate module. Baseapp implements all the [ABCI methods](https://docs.cometbft.com/v1.0/spec/abci/) and the [routing logic](../advanced/00-baseapp.md#service-routers).
     * It configures automatically the **[module manager](../../build/building-modules/01-module-manager.md#manager)** based on the app wiring configuration. The module manager facilitates operations related to these modules, like registering their [`Msg` service](../../build/building-modules/03-msg-services.md) and [gRPC `Query` service](#grpc-query-services), or setting the order of execution between modules for various functions like [`InitChainer`](#initchainer), [`PreBlocker`](#preblocker) and [`BeginBlocker` and `EndBlocker`](#beginblocker-and-endblocker).
 * [**An App Wiring configuration file**](../../build/building-apps/00-runtime.md) The app wiring configuration file contains the list of application's modules that `runtime` must instantiate. The instantiation of the modules are done using `depinject`. It contains as well at which order the modules `InitGenesis`, `Pre/Begin/EndBlocker` should be executed.
diff --git a/schema/type.go b/schema/type.go
new file mode 100644
index 000000000000..5d6a43a278a3
--- /dev/null
+++ b/schema/type.go
@@ -0,0 +1,84 @@
+package schema
+
+// Type is an interface that all types in the schema implement.
+// Currently, these are StateObjectType and EnumType.
+type Type interface {
+	// TypeName returns the type's name.
+	TypeName() string
+
+	// Validate validates the type.
+	Validate(TypeSet) error
+
+	// isType is a private method that ensures that only types in this package can be marked as types.
+	isType()
+}
+
+// ReferenceableType is a marker interface that all types that can be the target of Field.ReferencedType implement.
+// Currently, this is only EnumType.
+type ReferenceableType interface {
+	Type
+
+	// isReferenceableType is implemented if this is a reference type.
+	isReferenceableType()
+}
+
+// TypeSet represents something that has types and allows them to be looked up by name.
+// Currently, the only implementation is ModuleSchema.
+type TypeSet interface {
+	// LookupType looks up a type by name.
+	LookupType(name string) (t Type, found bool)
+
+	// LookupEnumType is a convenience method that looks up an EnumType by name.
+	LookupEnumType(name string) (t EnumType, found bool)
+
+	// LookupStateObjectType is a convenience method that looks up an StateObjectType by name.
+	LookupStateObjectType(name string) (t StateObjectType, found bool)
+
+	// AllTypes calls the given function for each type in the type set.
+	// This function is compatible with go 1.23 iterators and can be used like this:
+	// for t := range types.AllTypes {
+	//     // do something with t
+	// }
+	AllTypes(f func(Type) bool)
+
+	// EnumTypes calls the given function for each EnumType in the type set.
+	// This function is compatible with go 1.23 iterators.
+	EnumTypes(f func(EnumType) bool)
+
+	// StateObjectTypes calls the given function for each StateObjectType in the type set.
+	// This function is compatible with go 1.23 iterators.
+	StateObjectTypes(f func(objectType StateObjectType) bool)
+
+	// isTypeSet is a private method that ensures that only types in this package can be marked as type sets.
+	isTypeSet()
+}
+
+// EmptyTypeSet is a schema that contains no types.
+// It can be used in Validate methods when there is no schema needed or available.
+func EmptyTypeSet() TypeSet {
+	return emptyTypeSetInst
+}
+
+var emptyTypeSetInst = emptyTypeSet{}
+
+type emptyTypeSet struct{}
+
+func (emptyTypeSet) LookupType(string) (Type, bool) {
+	return nil, false
+}
+
+func (s emptyTypeSet) LookupEnumType(string) (t EnumType, found bool) {
+	return EnumType{}, false
+}
+
+func (s emptyTypeSet) LookupStateObjectType(string) (t StateObjectType, found bool) {
+	return StateObjectType{}, false
+}
+
+func (emptyTypeSet) AllTypes(func(Type) bool) {}
+
+func (s emptyTypeSet) EnumTypes(func(EnumType) bool) {}
+
+func (s emptyTypeSet) StateObjectTypes(func(objectType StateObjectType) bool) {}
+
+func (emptyTypeSet) isTypeSet() {}