diff --git a/package.json b/package.json
index ae34fb9..ff0b823 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@thilawyn/traitify-ts",
-  "version": "0.1.21",
+  "version": "0.1.22",
   "type": "module",
   "publishConfig": {
     "registry": "https://git.jvalver.de/api/packages/thilawyn/npm/"
@@ -30,12 +30,12 @@
         "default": "./dist/effect/lib.cjs"
       }
     },
-    "./traitsUnique-CJ9oW-Fc": {
+    "./traitsUnique-h-N6REho": {
       "import": {
-        "types": "./dist/traitsUnique-CJ9oW-Fc.d.ts"
+        "types": "./dist/traitsUnique-h-N6REho.d.ts"
       },
       "require": {
-        "types": "./dist/traitsUnique-CJ9oW-Fc.d.ts"
+        "types": "./dist/traitsUnique-h-N6REho.d.ts"
       }
     }
   },
diff --git a/src/Trait.ts b/src/Trait.ts
index d2f1f2e..54d2992 100644
--- a/src/Trait.ts
+++ b/src/Trait.ts
@@ -1,4 +1,4 @@
-import { AbstractClass, Class, Simplify } from "type-fest"
+import { AbstractConstructor, Constructor, Simplify } from "type-fest"
 import { TraitExpression } from "./TraitExpression"
 import { Extend, StaticMembers } from "./util"
 
@@ -10,13 +10,13 @@ export class Trait<
     >,
     Abstract        extends object,
     StaticAbstract  extends object,
-    ImplClass       extends AbstractClass<object, []>,
+    ImplClass       extends AbstractConstructor<object, []>,
 > {
     constructor(
         readonly superExpression:  SuperExpression,
         readonly abstract:         Abstract,
         readonly staticAbstract:   StaticAbstract,
-        readonly apply:            (Super: AbstractClass<object>) => ImplClass,
+        readonly apply:            (Super: AbstractConstructor<object>) => ImplClass,
     ) {}
 }
 
@@ -118,12 +118,12 @@ export namespace TraitTuple {
 
 
 export type TraitClass<T extends Trait<any, any, any, any>> = (
-    AbstractClass<TraitInstance<T>, any[]> &
+    AbstractConstructor<TraitInstance<T>, any[]> &
     TraitStaticMembers<T>
 )
 
 export type TraitConcreteClass<T extends Trait<any, any, any, any>> = (
-    Class<TraitInstance<T>, any[]> &
+    Constructor<TraitInstance<T>, any[]> &
     TraitStaticMembers<T>
 )
 
diff --git a/src/TraitBuilder.ts b/src/TraitBuilder.ts
index 76a7b60..6be7003 100644
--- a/src/TraitBuilder.ts
+++ b/src/TraitBuilder.ts
@@ -1,4 +1,4 @@
-import { AbstractClass, Class, Simplify } from "type-fest"
+import { AbstractConstructor, Constructor, Simplify } from "type-fest"
 import { Trait } from "./Trait"
 import { TraitExpression } from "./TraitExpression"
 import { Extend, StaticMembers } from "./util"
@@ -14,22 +14,20 @@ export class TraitBuilder<
     >,
     Abstract        extends object,
     StaticAbstract  extends object,
-    ImplClass       extends AbstractClass<object, []>,
+    ImplClass       extends AbstractConstructor<object, []>,
 > {
-    declare ["constructor"]: typeof TraitBuilder
-
     constructor(
         readonly traitSuperExpression:  SuperExpression,
         readonly traitAbstract:         Abstract,
         readonly traitStaticAbstract:   StaticAbstract,
-        readonly traitApply:            (Super: AbstractClass<object>) => ImplClass,
+        readonly traitApply:            (Super: AbstractConstructor<object>) => ImplClass,
     ) {}
 
 
     abstract<A extends Abstract>(
-        _: (Super: AbstractClass<Abstract>) => AbstractClass<A, []>
+        _: (Super: AbstractConstructor<Abstract>) => AbstractConstructor<A, []>
     ) {
-        return new this.constructor(
+        return new TraitBuilder(
             this.traitSuperExpression,
             {} as Simplify<A>,
             this.traitStaticAbstract,
@@ -38,9 +36,9 @@ export class TraitBuilder<
     }
 
     staticAbstract<A extends StaticAbstract>(
-        _: (Super: AbstractClass<StaticAbstract>) => AbstractClass<A, []>
+        _: (Super: AbstractConstructor<StaticAbstract>) => AbstractConstructor<A, []>
     ) {
-        return new this.constructor(
+        return new TraitBuilder(
             this.traitSuperExpression,
             this.traitAbstract,
             {} as Simplify<A>,
@@ -53,13 +51,13 @@ export class TraitBuilder<
     >(
         apply: (Super: TraitBuilder.ImplSuper<typeof this>) => ImplClassWithAbstract
     ) {
-        return new this.constructor(
+        return new TraitBuilder(
             this.traitSuperExpression,
             this.traitAbstract,
             this.traitStaticAbstract,
 
-            apply as unknown as (Super: AbstractClass<object>) => (
-                AbstractClass<
+            apply as unknown as (Super: AbstractConstructor<object>) => (
+                AbstractConstructor<
                     Simplify<
                         Omit<
                             InstanceType<ImplClassWithAbstract>,
@@ -98,7 +96,7 @@ export namespace TraitBuilder {
             infer ImplClass
         >
             ? (
-                AbstractClass<
+                AbstractConstructor<
                     Simplify<
                         Extend<[
                             Abstract,
@@ -121,7 +119,7 @@ export namespace TraitBuilder {
 
 
 export type ImplStatic<
-    ImplClass extends AbstractClass<object> & { readonly [implSuperSymbol]: true }
+    ImplClass extends AbstractConstructor<object> & { readonly [implSuperSymbol]: true }
 > = (
     Simplify<
         Omit<StaticMembers<ImplClass>, typeof implSuperSymbol>
@@ -129,14 +127,14 @@ export type ImplStatic<
 )
 
 export function implStaticThis<
-    ImplClass extends AbstractClass<object> & { readonly [implSuperSymbol]: true },
-    This      extends AbstractClass<object>,
+    ImplClass extends AbstractConstructor<object> & { readonly [implSuperSymbol]: true },
+    This      extends AbstractConstructor<object>,
 >(
     _Impl:    ImplClass,
     thisArg:  This,
 ) {
     return thisArg as unknown as (
-        AbstractClass<
+        AbstractConstructor<
             InstanceType<ImplClass> & InstanceType<This>,
             ConstructorParameters<This>
         > &
@@ -146,14 +144,14 @@ export function implStaticThis<
 }
 
 export function implStaticInstantiableThis<
-    ImplClass extends AbstractClass<object> & { readonly [implSuperSymbol]: true },
-    This      extends Class<object>,
+    ImplClass extends AbstractConstructor<object> & { readonly [implSuperSymbol]: true },
+    This      extends Constructor<object>,
 >(
     _Impl:    ImplClass,
     thisArg:  This,
 ) {
     return thisArg as unknown as (
-        Class<
+        Constructor<
             InstanceType<ImplClass> & InstanceType<This>,
             ConstructorParameters<This>
         > &
@@ -167,5 +165,5 @@ export const trait = new TraitBuilder(
     new TraitExpression(TraitExpression.NullSuperclass, []),
     {} as object,
     {} as object,
-    Super => class extends Super {} as AbstractClass<object>,
+    Super => class extends Super {} as AbstractConstructor<object>,
 )
diff --git a/src/TraitExpression.ts b/src/TraitExpression.ts
index 1198170..0021168 100644
--- a/src/TraitExpression.ts
+++ b/src/TraitExpression.ts
@@ -1,11 +1,11 @@
-import { AbstractClass, Class, Simplify } from "type-fest"
+import { AbstractConstructor, Constructor, Simplify } from "type-fest"
 import { Trait, TraitTuple } from "./Trait"
 import { TraitBuilder } from "./TraitBuilder"
 import { Extend, StaticMembers } from "./util"
 
 
 export type TraitExpressionLike<
-    Superclass extends AbstractClass<object>,
+    Superclass extends AbstractConstructor<object>,
     Traits     extends readonly Trait<any, any, any, any>[],
 > = {
     readonly superclass:  Superclass,
@@ -14,7 +14,7 @@ export type TraitExpressionLike<
 
 
 export class TraitExpression<
-    Superclass   extends AbstractClass<object>,
+    Superclass   extends AbstractConstructor<object>,
     const Traits extends readonly Trait<any, any, any, any>[],
 >
 implements TraitExpressionLike<Superclass, Traits> {
@@ -25,7 +25,7 @@ implements TraitExpressionLike<Superclass, Traits> {
 
 
     get extends(): (
-        AbstractClass<
+        AbstractConstructor<
             InstanceType<Superclass> &  // Keep the instance of the superclass outside of any kind of type manipulation
                                         // as it can accidentely remove abstract properties
             Simplify<
@@ -69,7 +69,7 @@ implements TraitExpressionLike<Superclass, Traits> {
                 Extend<TraitTuple.MapStaticAbstract<Traits>>
             >,
 
-            AbstractClass<
+            AbstractConstructor<
                 Simplify<
                     Extend<TraitTuple.MapImplInstance<Traits>>
                 >
@@ -135,7 +135,7 @@ export type StaticImplements<
 export type TraitExpressionClass<
     Exp extends TraitExpressionLike<any, readonly Trait<any, any, any, any>[]>
 > = (
-    AbstractClass<
+    AbstractConstructor<
         TraitExpressionInstance<Exp>,
         ConstructorParameters<TraitExpression.Superclass<Exp>>
     > &
@@ -145,7 +145,7 @@ export type TraitExpressionClass<
 export type TraitExpressionConcreteClass<
     Exp extends TraitExpressionLike<any, readonly Trait<any, any, any, any>[]>
 > = (
-    Class<
+    Constructor<
         TraitExpressionInstance<Exp>,
         ConstructorParameters<TraitExpression.Superclass<Exp>>
     > &
diff --git a/src/TraitExpressionBuilder.ts b/src/TraitExpressionBuilder.ts
index 464740d..6b1e47b 100644
--- a/src/TraitExpressionBuilder.ts
+++ b/src/TraitExpressionBuilder.ts
@@ -1,4 +1,4 @@
-import { AbstractClass } from "type-fest"
+import { AbstractConstructor } from "type-fest"
 import { Trait, TraitTuple } from "./Trait"
 import { TraitExpression } from "./TraitExpression"
 import { SpreadSupertraits, spreadSupertraits } from "./spreadSupertraits"
@@ -7,7 +7,7 @@ import { Extendable, StaticMembers } from "./util"
 
 
 export class TraitExpressionBuilder<
-    Superclass   extends AbstractClass<object>,
+    Superclass   extends AbstractConstructor<object>,
     const Traits extends readonly Trait<any, any, any, any>[],
 > {
     constructor(
@@ -17,7 +17,7 @@ export class TraitExpressionBuilder<
 
 
     extends<
-        Super extends AbstractClass<object>
+        Super extends AbstractConstructor<object>
     >(
         superclass: Super
     ) {
@@ -125,7 +125,7 @@ export namespace TraitExpressionBuilder {
     )
 
     export type BuildTraitExpression<
-        Superclass extends AbstractClass<object>,
+        Superclass extends AbstractConstructor<object>,
         Traits     extends readonly Trait<any, any, any, any>[],
     > = (
         Extendable<TraitTuple.MapAbstract<Traits>> extends false
diff --git a/src/effect/tests.ts b/src/effect/tests.ts
index 5052c90..999243f 100644
--- a/src/effect/tests.ts
+++ b/src/effect/tests.ts
@@ -1,6 +1,5 @@
 import { Schema as S } from "@effect/schema"
 import { Implements } from "../TraitExpression"
-import { EffectSchemaTraitExpression } from "./EffectSchemaTraitExpression"
 import { effectSchemaExpression } from "./EffectSchemaTraitExpressionBuilder"
 
 
diff --git a/src/util/misc.ts b/src/util/misc.ts
index 175ddfd..c2a1306 100644
--- a/src/util/misc.ts
+++ b/src/util/misc.ts
@@ -1,4 +1,4 @@
-import { AbstractClass } from "type-fest"
+import { AbstractConstructor } from "type-fest"
 
 
 /**
@@ -10,8 +10,8 @@ export type CommonKeys<A, B> = Extract<keyof A, keyof B>
 
 /**
  * Represents the static members of a class.
- * @template Class - A class extending AbstractClass.
+ * @template Class - A class.
  */
-export type StaticMembers<Class extends AbstractClass<any>> = (
+export type StaticMembers<Class extends AbstractConstructor<any>> = (
     Omit<Class, "prototype">
 )