ZodSchemaClassBuilder

package.json

@@ -48,7 +48,7 @@
     "clean:node": "rm -rf node_modules"
   },
   "dependencies": {
-    "@thilawyn/traitify-ts": "^0.1.9",
+    "@thilawyn/traitify-ts": "^0.1.10",
     "decimal.js": "^10.4.3",
     "effect": "^2.4.0",
     "lodash-es": "^4.17.21",

src/ZodSchemaClass.ts

@@ -1,4 +1,4 @@
-import { Trait, TraitExpressionBuilder, expression } from "@thilawyn/traitify-ts"
+import { TraitExpression, TraitExpressionBuilder, expression } from "@thilawyn/traitify-ts"
 import { AbstractClass, Simplify } from "type-fest"
 import { z } from "zod"
 import { ExtendableZodSchemaObject } from "./traits/ExtendableZodSchemaObject"
@@ -7,10 +7,75 @@ import { Extend, StaticMembers } from "./util"
 
 
 export class ZodSchemaClassBuilder<
-    Superclass   extends AbstractClass<object>,
+    Exp extends TraitExpressionBuilder<any, any>
-    const Traits extends Trait<any, any, any, any>[],
+> {
->
+    constructor(
-extends TraitExpressionBuilder<Superclass, Traits> {
+        private readonly expressionBuilder: Exp
+    ) {}
+
+    extends<
+        This  extends ZodSchemaClassBuilder<
+            TraitExpressionBuilder<
+                typeof TraitExpression.NullSuperclass,  // Ensures `extends` can only be called when the expression does not have a superclass
+                any
+            >
+        >,
+        Super extends AbstractClass<object, []>,
+    >(
+        this:        This,
+        superclass:  Super,
+    ) {
+        return new ZodSchemaClassBuilder(
+            this.expressionBuilder.extends(superclass)
+        )
+    }
+
+    schema<
+        This extends ZodSchemaClassBuilder<
+            TraitExpressionBuilder<
+                any,
+                any
+            >
+        >,
+
+        SchemaT           extends z.ZodRawShape,
+        SchemaUnknownKeys extends z.UnknownKeysParam,
+        SchemaCatchall    extends z.ZodTypeAny,
+
+        Values            extends object,
+        DefaultValues     extends Partial<Values>,
+    >(
+        this:           This,
+        schema:         z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>,
+        defaultValues:  DefaultValues,
+    ) {
+        class Schemas extends (this.expressionBuilder.expressionSuperclass as AbstractClass<object, []>) {
+            static readonly schema        = schema
+            static readonly defaultValues = defaultValues
+
+            constructor(values: Values) {
+                super()
+                Object.assign(this, values)
+            }
+        }
+
+        return new ZodSchemaClassBuilder(
+            this.expressionBuilder
+                .extends()
+                .expresses(
+                    InstantiableZodSchemaObject,
+                    ExtendableZodSchemaObject,
+                )
+        )
+    }
+
+    jsonifiable() {
+
+    }
+
+    toBuilder() {
+        return this.expressionBuilder
+    }
 }