From 0e4d45a1cea53e42f5c77a3c172581e62b4d13b0 Mon Sep 17 00:00:00 2001
From: Patrick Roza <contact@patrickroza.com>
Date: Tue, 1 Feb 2022 09:24:24 +0100
Subject: [PATCH 1/3] fix (schema): Model types

---
 packages/schema/src/_api/model.ts | 16 +++-------------
 1 file changed, 3 insertions(+), 13 deletions(-)

diff --git a/packages/schema/src/_api/model.ts b/packages/schema/src/_api/model.ts
index 764675b..67a450b 100644
--- a/packages/schema/src/_api/model.ts
+++ b/packages/schema/src/_api/model.ts
@@ -10,10 +10,10 @@ import * as S from "./schemed"
 
 export type SchemaForModel<M, Self extends MO.SchemaAny> = MO.Schema<
   MO.ParserInputOf<Self>,
-  MO.ParserErrorOf<Self>,
+  MO.NamedE<string, MO.ParserErrorOf<Self>>,
   M,
   MO.ConstructorInputOf<Self>,
-  MO.ConstructorErrorOf<Self>,
+  MO.NamedE<string, MO.ConstructorErrorOf<Self>>,
   MO.EncodedOf<Self>,
   MO.ApiOf<Self> & MO.ApiSelfType<M>
 >
@@ -47,17 +47,7 @@ export type ModelFor<M, Self extends MO.SchemaAny> = M extends MO.ParsedShapeOf<
 
 export interface Model<M, Self extends MO.SchemaAny>
   extends S.Schemed<Self>,
-    MO.Schema<
-      MO.ParserInputOf<Self>,
-      MO.NamedE<string, MO.ParserErrorOf<Self>>,
-      M,
-      MO.ConstructorInputOf<Self>,
-      MO.NamedE<string, MO.ConstructorErrorOf<Self>>,
-      MO.EncodedOf<Self>,
-      MO.ApiOf<Self>
-    > {
-  [S.schemaField]: Self
-
+    SchemaForModel<M, Self> {
   readonly Parser: ParserFor<SchemaForModel<M, Self>>
 
   readonly Constructor: ConstructorFor<SchemaForModel<M, Self>>

From d57f57f2cf10d40bd0db850465431fb59d6ec1a9 Mon Sep 17 00:00:00 2001
From: Patrick Roza <contact@patrickroza.com>
Date: Tue, 1 Feb 2022 10:07:44 +0100
Subject: [PATCH 2/3] Fix withDefaults - Arbitrary

---
 packages/schema/src/_api/withDefaults.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/schema/src/_api/withDefaults.ts b/packages/schema/src/_api/withDefaults.ts
index 23586cb..fd97a29 100644
--- a/packages/schema/src/_api/withDefaults.ts
+++ b/packages/schema/src/_api/withDefaults.ts
@@ -41,7 +41,7 @@ export interface SchemaDefaultSchema<
 
   readonly Guard: Guard.Guard<ParsedShape>
 
-  readonly Arbitrary: Arbitrary.Arbitrary<ParsedShape>
+  readonly Arbitrary: Arbitrary.Gen<ParsedShape>
 
   readonly annotate: <Meta>(
     identifier: Annotation<Meta>,

From 0cab0b2c7f2885b8cdd62b07ee24f091dc61eabf Mon Sep 17 00:00:00 2001
From: Patrick Roza <contact@patrickroza.com>
Date: Tue, 1 Feb 2022 10:26:47 +0100
Subject: [PATCH 3/3] Fix inference

---
 packages/schema/src/_api/model.ts | 111 ++++++++++++++++++++++++------
 1 file changed, 91 insertions(+), 20 deletions(-)

diff --git a/packages/schema/src/_api/model.ts b/packages/schema/src/_api/model.ts
index 67a450b..b6c002d 100644
--- a/packages/schema/src/_api/model.ts
+++ b/packages/schema/src/_api/model.ts
@@ -7,15 +7,34 @@ import * as Encoder from "../Encoder"
 import * as Guard from "../Guard"
 import * as Parser from "../Parser"
 import * as S from "./schemed"
-
-export type SchemaForModel<M, Self extends MO.SchemaAny> = MO.Schema<
+import type { SchemaDefaultSchema } from "./withDefaults"
+
+interface SchemaModel<
+  ParserInput,
+  ParserError extends MO.AnyError,
+  ParsedShape,
+  ConstructorInput,
+  ConstructorError extends MO.AnyError,
+  Encoded,
+  Api
+> extends SchemaDefaultSchema<
+    ParserInput,
+    MO.NamedE<string, ParserError>,
+    ParsedShape,
+    ConstructorInput,
+    MO.NamedE<string, ConstructorError>,
+    Encoded,
+    Api & MO.ApiSelfType<ParsedShape>
+  > {}
+
+export type SchemaForModel<M, Self extends MO.SchemaAny> = SchemaModel<
   MO.ParserInputOf<Self>,
-  MO.NamedE<string, MO.ParserErrorOf<Self>>,
+  MO.ParserErrorOf<Self>,
   M,
   MO.ConstructorInputOf<Self>,
-  MO.NamedE<string, MO.ConstructorErrorOf<Self>>,
+  MO.ConstructorErrorOf<Self>,
   MO.EncodedOf<Self>,
-  MO.ApiOf<Self> & MO.ApiSelfType<M>
+  MO.ApiOf<Self>
 >
 
 export type ParserFor<Self extends MO.SchemaAny> = Parser.Parser<
@@ -45,19 +64,45 @@ export type ModelFor<M, Self extends MO.SchemaAny> = M extends MO.ParsedShapeOf<
   ? SchemaForModel<M, Self>
   : SchemaForModel<MO.ParsedShapeOf<Self>, Self>
 
-export interface Model<M, Self extends MO.SchemaAny>
-  extends S.Schemed<Self>,
-    SchemaForModel<M, Self> {
-  readonly Parser: ParserFor<SchemaForModel<M, Self>>
-
-  readonly Constructor: ConstructorFor<SchemaForModel<M, Self>>
-
-  readonly Encoder: EncoderFor<SchemaForModel<M, Self>>
-
-  readonly Guard: GuardFor<SchemaForModel<M, Self>>
-
-  readonly Arbitrary: ArbitraryFor<SchemaForModel<M, Self>>
-}
+export interface ModelInfer<M, Self extends MO.SchemaAny>
+  extends Model<
+    MO.ParserInputOf<Self>,
+    MO.ParserErrorOf<Self>,
+    M,
+    MO.ConstructorInputOf<Self>,
+    MO.ConstructorErrorOf<Self>,
+    MO.EncodedOf<Self>,
+    MO.ApiOf<Self>
+  > {}
+
+export interface Model<
+  ParserInput,
+  ParserError extends MO.AnyError,
+  ParsedShape,
+  ConstructorInput,
+  ConstructorError extends MO.AnyError,
+  Encoded,
+  Api
+> extends S.Schemed<
+      SchemaModel<
+        ParserInput,
+        ParserError,
+        ParsedShape,
+        ConstructorInput,
+        ConstructorError,
+        Encoded,
+        Api
+      >
+    >,
+    SchemaModel<
+      ParserInput,
+      ParserError,
+      ParsedShape,
+      ConstructorInput,
+      ConstructorError,
+      Encoded,
+      Api
+    > {}
 
 export const NameSym = Symbol()
 
@@ -65,7 +110,33 @@ export const NameSym = Symbol()
  * @inject genericName
  */
 export function Model<M>(__name?: string) {
-  return <Self extends MO.SchemaAny>(self: Self): Model<M, Self> => {
+  return <
+    ParserInput,
+    ParserError extends MO.AnyError,
+    ParsedShape,
+    ConstructorInput,
+    ConstructorError extends MO.AnyError,
+    Encoded,
+    Api
+  >(
+    self: MO.Schema<
+      ParserInput,
+      ParserError,
+      ParsedShape,
+      ConstructorInput,
+      ConstructorError,
+      Encoded,
+      Api
+    >
+  ): Model<
+    ParserInput,
+    ParserError,
+    ParsedShape,
+    ConstructorInput,
+    ConstructorError,
+    Encoded,
+    Api
+  > => {
     const schemed = S.Schemed(named(__name ?? "Model(Anonymous)")(self))
     const schema = S.schema(schemed)
 
@@ -115,7 +186,7 @@ export function Model<M>(__name?: string) {
   }
 }
 
-export function stable<T, A extends MO.SchemaAny>(constructor: Model<T, A>) {
+export function stable<T, A extends MO.SchemaAny>(constructor: ModelInfer<T, A>) {
   const schema = named(constructor[NameSym] ?? "Model(Anonymous)")(
     S.schema(constructor)
   )