Moved Trait helper types to a namespace

src/Trait.ts

@@ -39,61 +39,62 @@ export class Trait<
     ) {}
 }
 
-export type TraitOwnAbstract<T> = (
+export namespace Trait {
+    export type OwnAbstract<T> = (
         T extends Trait<any, infer Abstract, any>
             ? Abstract
             : never
     )
-export interface TraitOwnAbstractFn extends Fn {
+    export interface OwnAbstractFn extends Fn {
-    return: TraitOwnAbstract<this["arg0"]>
+        return: Trait.OwnAbstract<this["arg0"]>
     }
 
-export type TraitOwnImplClass<T> = (
+    export type OwnImplClass<T> = (
         T extends Trait<any, any, infer ImplClass>
             ? ImplClass
             : never
     )
-export interface TraitOwnImplClassFn extends Fn {
+    export interface OwnImplClassFn extends Fn {
-    return: TraitOwnImplClass<this["arg0"]>
+        return: Trait.OwnImplClass<this["arg0"]>
     }
 
-export type TraitOwnImplInstance<T> = (
+    export type OwnImplInstance<T> = (
         T extends Trait<any, any, infer ImplClass>
             ? InstanceType<ImplClass>
             : never
     )
-export interface TraitOwnImplInstanceFn extends Fn {
+    export interface OwnImplInstanceFn extends Fn {
-    return: TraitOwnImplInstance<this["arg0"]>
+        return: Trait.OwnImplInstance<this["arg0"]>
     }
 
-export type TraitOwnClass<T> = (
+    export type OwnClass<T> = (
         T extends Trait<any, infer Abstract, infer ImplClass>
             ? AddAbstractToImplClass<ImplClass, Abstract>
             : never
     )
-export interface TraitOwnClassFn extends Fn {
+    export interface OwnClassFn extends Fn {
-    return: TraitOwnClass<this["arg0"]>
+        return: Trait.OwnClass<this["arg0"]>
     }
 
-export type TraitOwnInstance<T> = (
+    export type OwnInstance<T> = (
         T extends Trait<any, infer Abstract, infer ImplClass>
             ? InstanceType<
                 AddAbstractToImplClass<ImplClass, Abstract>
             >
             : never
     )
-export interface TraitOwnInstanceFn extends Fn {
+    export interface OwnInstanceFn extends Fn {
-    return: TraitOwnInstance<this["arg0"]>
+        return: Trait.OwnInstance<this["arg0"]>
     }
 
-
+    export type Supertraits<T> = (
-export type TraitSupertraits<T> = (
         T extends Trait<infer Super, any, any>
             ? TraitExpressionAllTraits<Super>
             : never
     )
-export interface TraitSupertraitsFn extends Fn {
+    export interface SupertraitsFn extends Fn {
-    return: TraitSupertraits<this["arg0"]>
+        return: Trait.Supertraits<this["arg0"]>
+    }
 }
 
 

src/TraitExpressionBuilder.ts

@@ -1,6 +1,6 @@
 import { Call, Fn, Pipe, Tuples } from "hotscript"
 import { AbstractClass } from "type-fest"
-import { Trait, TraitExpression, TraitOwnAbstractFn, TraitOwnImplClassFn, TraitOwnImplInstanceFn, emptyTraitExpression } from "."
+import { Trait, TraitExpression, emptyTraitExpression } from "."
 import { ExtendableFn, StaticMembersFn } from "./util"
 
 
@@ -87,7 +87,7 @@ type AbstractMembersExtendable<
 > = (
     Call<ExtendableFn, [
         InstanceType<Super>,
-        ...Call<Tuples.Map<TraitOwnAbstractFn>, Traits>,
+        ...Call<Tuples.Map<Trait.OwnAbstractFn>, Traits>,
     ]>
 )
 
@@ -97,7 +97,7 @@ type ImplInstanceExtendable<
 > = (
     Call<ExtendableFn, [
         InstanceType<Super>,
-        ...Call<Tuples.Map<TraitOwnImplInstanceFn>, Traits>,
+        ...Call<Tuples.Map<Trait.OwnImplInstanceFn>, Traits>,
     ]>
 )
 
@@ -107,7 +107,7 @@ type ImplStaticMembersExtendable<
 > = (
     Pipe<[
         Super,
-        ...Call<Tuples.Map<TraitOwnImplClassFn>, Traits>,
+        ...Call<Tuples.Map<Trait.OwnImplClassFn>, Traits>,
     ], [
         Tuples.Map<StaticMembersFn>,
         ExtendableFn,

src/tests.ts

@@ -1,4 +1,4 @@
-import { Implements, abstract, expression, trait } from "."
+import { Implements, Trait, abstract, expression, trait } from "."
 
 
 const PrintsHelloOnNew = trait(