src/ZodSchemaClass.ts

@@ -1,4 +1,4 @@
-import { TraitExpression, TraitExpressionBuilder, expression } from "@thilawyn/traitify-ts"
+import { Trait, TraitExpression, TraitExpressionBuilder, expression } from "@thilawyn/traitify-ts"
 import { AbstractClass, Simplify } from "type-fest"
 import { z } from "zod"
 import { ExtendableZodSchemaObject } from "./traits/ExtendableZodSchemaObject"
@@ -7,18 +7,17 @@ import { Extend, StaticMembers } from "./util"
 
 
 export class ZodSchemaClassBuilder<
-    Exp extends TraitExpressionBuilder<any, any>
+    Superclass   extends AbstractClass<object>,
+    const Traits extends Trait<any, any, any, any>[],
 > {
     constructor(
-        private readonly expressionBuilder: Exp
+        private readonly expressionBuilder: TraitExpressionBuilder<Superclass, Traits>
     ) {}
 
     extends<
         This  extends ZodSchemaClassBuilder<
-            TraitExpressionBuilder<
             typeof TraitExpression.NullSuperclass,  // Ensures `extends` can only be called when the expression does not have a superclass
-                any
-            >
+            Traits
         >,
         Super extends AbstractClass<object, []>,
     >(
@@ -31,13 +30,6 @@ export class ZodSchemaClassBuilder<
     }
 
     schema<
-        This extends ZodSchemaClassBuilder<
-            TraitExpressionBuilder<
-                any,
-                any
-            >
-        >,
-
         SchemaT           extends z.ZodRawShape,
         SchemaUnknownKeys extends z.UnknownKeysParam,
         SchemaCatchall    extends z.ZodTypeAny,
@@ -45,7 +37,7 @@ export class ZodSchemaClassBuilder<
         Values            extends object,
         DefaultValues     extends Partial<Values>,
     >(
-        this:           This,
+        // this:           This,
         schema:         z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>,
         defaultValues:  DefaultValues,
     ) {
@@ -61,7 +53,22 @@ export class ZodSchemaClassBuilder<
 
         return new ZodSchemaClassBuilder(
             this.expressionBuilder
-                .extends()
+                .extends(Schemas as unknown as (
+                    AbstractClass<
+                        InstanceType<Superclass> &
+                        Simplify<
+                            Extend<[Schemas, Values]>
+                        >,
+
+                        ConstructorParameters<typeof Schemas>
+                    > &
+                    Simplify<
+                        Extend<[
+                            StaticMembers<Superclass>,
+                            StaticMembers<typeof Schemas>,
+                        ]>
+                    >
+                ))
                 .expresses(
                     InstantiableZodSchemaObject,
                     ExtendableZodSchemaObject,

src/tests.ts

@@ -1,9 +1,21 @@
-import { Implements } from "@thilawyn/traitify-ts"
+import { Implements, expression } from "@thilawyn/traitify-ts"
 import { z } from "zod"
-import { ZodSchemaClass } from "./ZodSchemaClass"
+import { ZodSchemaClass, ZodSchemaClassBuilder } from "./ZodSchemaClass"
 import { ObservableZodSchemaObject } from "./traits/ObservableZodSchemaObject"
 
 
+const newTestExp = new ZodSchemaClassBuilder(expression)
+    .schema(
+        z.object({
+            id: z.bigint()
+        }),
+
+        { id: -1n },
+    )
+    .toBuilder()
+    .expressionSuperclass
+
+
 const TestExp = ZodSchemaClass({
     schema: z.object({
         /** Object ID */