diff --git a/src/TraitExpression.ts b/src/TraitExpression.ts
index b7a8f80..1198170 100644
--- a/src/TraitExpression.ts
+++ b/src/TraitExpression.ts
@@ -4,10 +4,20 @@ import { TraitBuilder } from "./TraitBuilder"
 import { Extend, StaticMembers } from "./util"
 
 
+export type TraitExpressionLike<
+    Superclass extends AbstractClass<object>,
+    Traits     extends readonly Trait<any, any, any, any>[],
+> = {
+    readonly superclass:  Superclass,
+    readonly traits:      Traits,
+}
+
+
 export class TraitExpression<
     Superclass   extends AbstractClass<object>,
     const Traits extends readonly Trait<any, any, any, any>[],
-> {
+>
+implements TraitExpressionLike<Superclass, Traits> {
     constructor(
         readonly superclass:  Superclass,
         readonly traits:      Traits,
@@ -84,13 +94,13 @@ export namespace TraitExpression {
     }
 
     export type Superclass<T> = (
-        T extends TraitExpression<infer Superclass, any>
+        T extends TraitExpressionLike<infer Superclass, any>
             ? Superclass
             : never
     )
 
     export type Traits<T> = (
-        T extends TraitExpression<any, infer Traits>
+        T extends TraitExpressionLike<any, infer Traits>
             ? Traits
             : never
     )
@@ -98,7 +108,7 @@ export namespace TraitExpression {
 
 
 export type Implements<
-    Exp extends TraitExpression<any, readonly Trait<any, any, any, any>[]>
+    Exp extends TraitExpressionLike<any, readonly Trait<any, any, any, any>[]>
 > = (
     Simplify<
         Extend<
@@ -110,7 +120,7 @@ export type Implements<
 )
 
 export type StaticImplements<
-    Exp extends TraitExpression<any, readonly Trait<any, any, any, any>[]>
+    Exp extends TraitExpressionLike<any, readonly Trait<any, any, any, any>[]>
 > = (
     Simplify<
         Extend<
@@ -123,7 +133,7 @@ export type StaticImplements<
 
 
 export type TraitExpressionClass<
-    Exp extends TraitExpression<any, readonly Trait<any, any, any, any>[]>
+    Exp extends TraitExpressionLike<any, readonly Trait<any, any, any, any>[]>
 > = (
     AbstractClass<
         TraitExpressionInstance<Exp>,
@@ -133,7 +143,7 @@ export type TraitExpressionClass<
 )
 
 export type TraitExpressionConcreteClass<
-    Exp extends TraitExpression<any, readonly Trait<any, any, any, any>[]>
+    Exp extends TraitExpressionLike<any, readonly Trait<any, any, any, any>[]>
 > = (
     Class<
         TraitExpressionInstance<Exp>,
@@ -143,7 +153,7 @@ export type TraitExpressionConcreteClass<
 )
 
 export type TraitExpressionInstance<
-    Exp extends TraitExpression<any, readonly Trait<any, any, any, any>[]>
+    Exp extends TraitExpressionLike<any, readonly Trait<any, any, any, any>[]>
 > = (
     InstanceType<TraitExpression.Superclass<Exp>> &  // Keep the instance of the superclass outside of any kind of type manipulation
                                                      // as it can accidentely remove abstract properties
@@ -155,7 +165,7 @@ export type TraitExpressionInstance<
 )
 
 export type TraitExpressionStaticMembers<
-    Exp extends TraitExpression<any, readonly Trait<any, any, any, any>[]>
+    Exp extends TraitExpressionLike<any, readonly Trait<any, any, any, any>[]>
 > = (
     Simplify<
         Extend<[
diff --git a/src/effect/EffectSchemaTraitExpression.ts b/src/effect/EffectSchemaTraitExpression.ts
index 95b978f..7f3cfd4 100644
--- a/src/effect/EffectSchemaTraitExpression.ts
+++ b/src/effect/EffectSchemaTraitExpression.ts
@@ -1,7 +1,7 @@
 import { Schema as S } from "@effect/schema"
 import { Simplify } from "type-fest"
 import { Trait, TraitTuple } from "../Trait"
-import { StaticImplements, TraitExpression } from "../TraitExpression"
+import { StaticImplements, TraitExpressionLike } from "../TraitExpression"
 import { Extend } from "../util"
 
 
@@ -16,6 +16,10 @@ export class EffectSchemaTraitExpression<
     Static       extends object,
 
     const Traits extends readonly Trait<any, any, any, any>[],
+>
+implements TraitExpressionLike<
+    S.Class<unknown, Fields, A, I, R, C, Inherited, Proto> & Static,
+    Traits
 > {
     constructor(
         readonly superclass:  S.Class<unknown, Fields, A, I, R, C, Inherited, Proto> & Static,
@@ -54,9 +58,9 @@ export class EffectSchemaTraitExpression<
     }
 
 
-    staticImplements(_target: StaticImplements<TraitExpression<typeof this.superclass, Traits>>, _context: any) {}
+    staticImplements(_target: StaticImplements<typeof this>, _context: any) {}
 
     get staticImplementsStage2() {
-        return (_target: StaticImplements<TraitExpression<typeof this.superclass, Traits>>) => {}
+        return (_target: StaticImplements<typeof this>) => {}
     }
 }
diff --git a/src/effect/tests.ts b/src/effect/tests.ts
index 7d6593f..8910c9c 100644
--- a/src/effect/tests.ts
+++ b/src/effect/tests.ts
@@ -12,6 +12,7 @@ const userExp = effectSchemaExpression
 
 @userExp.staticImplements
 class User extends userExp.extends<User>() implements Implements<typeof userExp> {
+    aMethodThatShouldBeInherited() {}
     static aStaticMethodThatShouldBeInherited() {}
 }
 
@@ -25,3 +26,5 @@ const adminExp = effectSchemaExpression
 @adminExp.staticImplements
 class Admin extends adminExp.extends<Admin>() implements Implements<typeof adminExp> {
 }
+
+new Admin({ id: 0n, role: "Admin" }).aMethodThatShouldBeInherited()