better typing

src/decorators/register.ts

 import {
+  ClassType,
   SchemaClassOptions,
   SchemaOptions,
   SchemaOptionsDict,
@@ -93,15 +94,13 @@ function schemaOptionsFromClass<C extends { new (...args: any[]): any }>(
   return result;
 }
 
-export function schemaFromClass<C extends { new (...args: any[]): any }>(
-  cl: C,
-): Schema<TypeFromClass<C>> {
+export function schemaFromClass<T>(cl: ClassType<T>): Schema<T> {
   let schema: Schema;
   const optionsDict = schemaOptionsFromClass(cl);
   if (!optionsDict) {
     schema = Schema.object({}, true);
   } else {
-    schema = schemasFromDict<TypeFromClass<C>>(optionsDict);
+    schema = schemasFromDict<T>(optionsDict);
   }
   const classOptions = reflector.get('SchemaClassOptions', cl);
   if (classOptions) {
@@ -124,9 +123,9 @@ const schemaFields: (keyof Schema.Base)[] = [
   'meta',
 ];
 
-function applySchemaForClass<C extends { new (...args: any[]): any }>(
-  originalClass: C,
-  instance: TypeFromClass<C>,
+function applySchemaForClass<T>(
+  originalClass: ClassType<T>,
+  instance: T,
   originalObject: any,
 ) {
   const schema = schemaFromClass(originalClass);
@@ -149,14 +148,14 @@ function applySchemaForClass<C extends { new (...args: any[]): any }>(
 }
 
 export function RegisterSchema(options: SchemaClassOptions = {}) {
-  return function <C extends { new (...args: any[]): any }>(originalClass: C) {
+  return function <T>(originalClass: ClassType<T>) {
     Metadata.set('SchemaClassOptions', options)(originalClass);
     const schema = schemaFromClass(originalClass);
     const newClass = (function (...args: any[]): any {
       const instance = new originalClass(...args);
       const originalObject = args[0];
       return applySchemaForClass(originalClass, instance, originalObject);
-    } as unknown) as C & Schema<TypeFromClass<C>>;
+    } as unknown) as ClassType<T> & Schema<T>;
     Object.defineProperty(newClass, 'name', {
       value: originalClass.name,
     });

src/def/interfaces.ts

 import Schema from 'schemastery';
 
 export type ClassType<T> = { new <T>(...args: any[]): T };
-export type TypeFromClass<C> = C extends { new (...args: any[]): infer T }
-  ? T
-  : never;
 
 export type SchemaType =
   | 'string'