diff --git a/src/describe/index.ts b/src/describe/index.ts
index 53e2bb8..5f17cb1 100644
--- a/src/describe/index.ts
+++ b/src/describe/index.ts
@@ -7,7 +7,7 @@ import {
   ISchema,
   Ref,
   AnySchema,
-  UnwrapOf,
+  Unwrap,
   AnySchemaWithProperties,
 } from '../structure/types';
 import { KeyedSchema } from '../structure/keyed';
@@ -47,15 +47,15 @@ export const tupleOf = <TSchema extends AnySchema>(
 export const optional = <TSchema extends AnySchema>(innerType: TSchema) =>
   new OptionalSchema(innerType);
 
-export const keyed = <K extends string, P extends ISchema<unknown, never>>(
+export const keyed = <K extends string, P extends ISchema<unknown>>(
   key: K,
-  inner: (ref: ISchema<Ref<K>, never>) => P,
+  inner: (ref: ISchema<Ref<K>>) => P,
 ) => new KeyedSchema(key, inner);
 
 export const concat = <Objs extends AnyObjectSchema[]>(objs: Objs) => {
   return new ObjectSchema(
     Object.fromEntries(
       objs.map(({ properties }) => Object.entries(properties)).flat(),
-    ) as unknown as MergeRecordUnion<UnwrapOf<Objs[number]>>,
+    ) as unknown as MergeRecordUnion<Unwrap<Objs[number]>>,
   );
 };
diff --git a/src/index.ts b/src/index.ts
index e0f8011..ec9b254 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -2,4 +2,4 @@ export * from './structure';
 export * from './describe';
 export * from './io';
 
-export type { Parsed } from './utilityTypes';
+export type { Parsed, ParseUnwrapped } from './utilityTypes';
diff --git a/src/structure/_internal.ts b/src/structure/_internal.ts
index a53f219..b5f3eb7 100644
--- a/src/structure/_internal.ts
+++ b/src/structure/_internal.ts
@@ -1,7 +1,8 @@
-export * from './types';
+export * from './array';
 export * from './baseTypes';
 export * from './chars';
-export * from './optional';
-export * from './object';
-export * from './array';
 export * from './keyed';
+export * from './object';
+export * from './optional';
+export * from './tuple';
+export * from './types';
diff --git a/src/structure/array.ts b/src/structure/array.ts
index 601bd99..ba51304 100644
--- a/src/structure/array.ts
+++ b/src/structure/array.ts
@@ -12,12 +12,15 @@ import {
   MaxValue,
   AnySchema,
   PropertyDescription,
+  Unwrap,
 } from './types';
 
-export class ArraySchema<TUnwrap extends AnySchema> extends Schema<TUnwrap[]> {
-  public elementType: TUnwrap;
+export class ArraySchema<TElement extends AnySchema> extends Schema<
+  Unwrap<TElement>[]
+> {
+  public elementType: TElement;
 
-  constructor(private readonly _unstableElementType: TUnwrap) {
+  constructor(private readonly _unstableElementType: TElement) {
     super();
 
     // In case this array isn't part of a keyed chain,
@@ -29,7 +32,7 @@ export class ArraySchema<TUnwrap extends AnySchema> extends Schema<TUnwrap[]> {
     this.elementType = ctx.resolve(this._unstableElementType);
   }
 
-  write(output: ISerialOutput, values: Parsed<TUnwrap>[]): void {
+  write(output: ISerialOutput, values: Parsed<Unwrap<TElement>>[]): void {
     output.writeUint32(values.length);
 
     for (const value of values) {
@@ -37,20 +40,20 @@ export class ArraySchema<TUnwrap extends AnySchema> extends Schema<TUnwrap[]> {
     }
   }
 
-  read(input: ISerialInput): Parsed<TUnwrap>[] {
-    const array: Parsed<TUnwrap>[] = [];
+  read(input: ISerialInput): Parsed<Unwrap<TElement>>[] {
+    const array: Parsed<Unwrap<TElement>>[] = [];
 
     const len = input.readUint32();
 
     for (let i = 0; i < len; ++i) {
-      array.push(this.elementType.read(input) as Parsed<TUnwrap>);
+      array.push(this.elementType.read(input) as Parsed<Unwrap<TElement>>);
     }
 
     return array;
   }
 
   measure(
-    values: Parsed<TUnwrap>[] | typeof MaxValue,
+    values: Parsed<Unwrap<TElement>>[] | typeof MaxValue,
     measurer: IMeasurer = new Measurer(),
   ): IMeasurer {
     if (values === MaxValue) {
@@ -70,7 +73,7 @@ export class ArraySchema<TUnwrap extends AnySchema> extends Schema<TUnwrap[]> {
   }
 
   seekProperty(
-    reference: Parsed<TUnwrap>[] | MaxValue,
+    reference: Parsed<Unwrap<TElement>>[] | MaxValue,
     prop: number,
   ): PropertyDescription | null {
     if (typeof prop === 'symbol') {
diff --git a/src/structure/index.ts b/src/structure/index.ts
index 93bfe52..49495bc 100644
--- a/src/structure/index.ts
+++ b/src/structure/index.ts
@@ -10,14 +10,19 @@ export {
   IRefResolver,
   Schema,
   ISchema,
+  Unwrap,
+  UnwrapRecord,
   ISchemaWithProperties,
   AnySchema,
-  AnyObjectSchema,
   AnySchemaWithProperties,
+
+  // Specific schemas
+  ArraySchema,
   KeyedSchema,
   CharsSchema,
-  ArraySchema,
+  TupleSchema,
   ObjectSchema,
+  AnyObjectSchema,
   GenericObjectSchema,
   OptionalSchema,
   SubTypeKey,
diff --git a/src/structure/keyed.ts b/src/structure/keyed.ts
index fc6af6a..39a38b5 100644
--- a/src/structure/keyed.ts
+++ b/src/structure/keyed.ts
@@ -1,6 +1,6 @@
 import { TypedBinaryError } from '../error';
 import { IMeasurer, ISerialInput, ISerialOutput, Measurer } from '../io';
-import { Parsed } from '../utilityTypes';
+import { ParseUnwrapped, Parsed } from '../utilityTypes';
 import {
   IRefResolver,
   ISchema,
@@ -8,11 +8,12 @@ import {
   MaxValue,
   PropertyDescription,
   AnySchema,
+  Unwrap,
+  IKeyedSchema,
 } from './types';
 
 class RefSchema<TKeyDef extends string> implements ISchema<Ref<TKeyDef>> {
   public readonly __unwrapped!: Ref<TKeyDef>;
-  public readonly __keyDefinition!: never;
   public readonly ref: Ref<TKeyDef>;
 
   constructor(key: TKeyDef) {
@@ -82,17 +83,17 @@ class RefResolve implements IRefResolver {
 }
 
 export class KeyedSchema<
-  TUnwrap extends ISchema<unknown>,
+  TInner extends ISchema<unknown>,
   TKeyDef extends string,
-> implements ISchema<TUnwrap, TKeyDef>
+> implements IKeyedSchema<Unwrap<TInner>, TKeyDef>
 {
-  public readonly __unwrapped!: TUnwrap;
+  public readonly __unwrapped!: Unwrap<TInner>;
   public readonly __keyDefinition!: TKeyDef;
-  public innerType: TUnwrap;
+  public innerType: TInner;
 
   constructor(
     public readonly key: TKeyDef,
-    innerResolver: (ref: ISchema<Ref<TKeyDef>, never>) => TUnwrap,
+    innerResolver: (ref: ISchema<Ref<TKeyDef>>) => TInner,
   ) {
     this.innerType = innerResolver(new RefSchema(key));
 
@@ -108,24 +109,24 @@ export class KeyedSchema<
     }
   }
 
-  read(input: ISerialInput): Parsed<TUnwrap> {
-    return this.innerType.read(input) as Parsed<TUnwrap>;
+  read(input: ISerialInput): ParseUnwrapped<TInner> {
+    return this.innerType.read(input) as ParseUnwrapped<TInner>;
   }
 
-  write(output: ISerialOutput, value: Parsed<TUnwrap>): void {
+  write(output: ISerialOutput, value: ParseUnwrapped<TInner>): void {
     this.innerType.write(output, value);
   }
 
   measure(
-    value: Parsed<TUnwrap> | typeof MaxValue,
+    value: ParseUnwrapped<TInner> | typeof MaxValue,
     measurer: IMeasurer = new Measurer(),
   ): IMeasurer {
     return this.innerType.measure(value, measurer);
   }
 
   seekProperty(
-    reference: Parsed<TUnwrap> | typeof MaxValue,
-    prop: keyof TUnwrap,
+    reference: ParseUnwrapped<TInner> | typeof MaxValue,
+    prop: keyof Unwrap<TInner>,
   ): PropertyDescription | null {
     return this.innerType.seekProperty(reference, prop as never);
   }
diff --git a/src/structure/object.ts b/src/structure/object.ts
index 7cdd7a7..de5319d 100644
--- a/src/structure/object.ts
+++ b/src/structure/object.ts
@@ -4,7 +4,7 @@ import {
   type ISerialInput,
   type ISerialOutput,
 } from '../io';
-import { Parsed } from '../utilityTypes';
+import { ParseUnwrappedRecord, Parsed } from '../utilityTypes';
 import { byte, string } from './baseTypes';
 import {
   Schema,
@@ -13,9 +13,10 @@ import {
   MaxValue,
   AnySchema,
   AnySchemaWithProperties,
-  UnwrapOf,
   ISchema,
   PropertyDescription,
+  Unwrap,
+  UnwrapRecord,
 } from './types';
 import { SubTypeKey } from './types';
 
@@ -40,13 +41,13 @@ export function resolveMap<T extends Record<string, AnySchema>>(
 
 export type AnyObjectSchema = ObjectSchema<Record<string, AnySchema>>;
 
-export class ObjectSchema<TUnwrap extends Record<string, AnySchema>>
-  extends Schema<TUnwrap>
-  implements ISchemaWithProperties<TUnwrap>
+export class ObjectSchema<TProps extends Record<string, AnySchema>>
+  extends Schema<UnwrapRecord<TProps>>
+  implements ISchemaWithProperties<TProps>
 {
-  public properties: TUnwrap;
+  public properties: TProps;
 
-  constructor(private readonly _properties: TUnwrap) {
+  constructor(private readonly _properties: TProps) {
     super();
 
     // In case this object isn't part of a keyed chain,
@@ -58,33 +59,33 @@ export class ObjectSchema<TUnwrap extends Record<string, AnySchema>>
     this.properties = resolveMap(ctx, this._properties);
   }
 
-  write(output: ISerialOutput, value: Parsed<TUnwrap>): void {
-    type Property = keyof Parsed<TUnwrap>;
+  write(output: ISerialOutput, value: ParseUnwrappedRecord<TProps>): void {
+    type Property = keyof ParseUnwrappedRecord<TProps>;
 
     for (const [key, property] of exactEntries(this.properties)) {
       property.write(output, value[key as Property]);
     }
   }
 
-  read(input: ISerialInput): Parsed<TUnwrap> {
-    type Property = keyof Parsed<TUnwrap>;
+  read(input: ISerialInput): ParseUnwrappedRecord<TProps> {
+    type Property = keyof ParseUnwrappedRecord<TProps>;
 
-    const result = {} as Parsed<TUnwrap>;
+    const result = {} as ParseUnwrappedRecord<TProps>;
 
     for (const [key, property] of exactEntries(this.properties)) {
-      result[key as Property] = property.read(
-        input,
-      ) as Parsed<TUnwrap>[Property];
+      result[key as Property] = property.read(input) as Parsed<
+        UnwrapRecord<TProps>
+      >[Property];
     }
 
     return result;
   }
 
   measure(
-    value: Parsed<TUnwrap> | typeof MaxValue,
+    value: ParseUnwrappedRecord<TProps> | typeof MaxValue,
     measurer: IMeasurer = new Measurer(),
   ): IMeasurer {
-    type Property = keyof Parsed<TUnwrap>;
+    type Property = keyof ParseUnwrappedRecord<TProps>;
 
     for (const [key, property] of exactEntries(this.properties)) {
       property.measure(
@@ -97,8 +98,8 @@ export class ObjectSchema<TUnwrap extends Record<string, AnySchema>>
   }
 
   seekProperty(
-    reference: Parsed<TUnwrap> | MaxValue,
-    prop: keyof TUnwrap,
+    reference: ParseUnwrappedRecord<TProps> | MaxValue,
+    prop: keyof UnwrapRecord<TProps>,
   ): PropertyDescription | null {
     let bufferOffset = 0;
 
@@ -117,26 +118,16 @@ export class ObjectSchema<TUnwrap extends Record<string, AnySchema>>
   }
 }
 
-export type AsSubTypes<T> = {
-  [K in keyof T]: T[K] extends ISchemaWithProperties<infer P>
-    ? P & { type: K }
-    : never;
-}[keyof T];
-
-export type StabilizedMap<T> = {
-  [K in keyof T]: T[K] extends ISchemaWithProperties<infer P>
-    ? ObjectSchema<P>
-    : never;
-};
-
-type UnwrapOfGeneric<Base extends Record<string, AnySchema>, Ext> = {
-  [TKey in keyof Ext]: ISchema<Base & { type: TKey } & UnwrapOf<Ext[TKey]>>;
+type UnwrapGeneric<Base extends Record<string, AnySchema>, Ext> = {
+  [TKey in keyof Ext]: ISchema<
+    UnwrapRecord<Base> & { type: TKey } & UnwrapRecord<Unwrap<Ext[TKey]>>
+  >;
 }[keyof Ext];
 
 export class GenericObjectSchema<
   TUnwrapBase extends Record<string, AnySchema>, // Base properties
   TUnwrapExt extends Record<string, AnySchemaWithProperties>, // Sub type map
-> extends Schema<UnwrapOfGeneric<TUnwrapBase, TUnwrapExt>> {
+> extends Schema<UnwrapGeneric<TUnwrapBase, TUnwrapExt>> {
   private _baseObject: ObjectSchema<TUnwrapBase>;
   public subTypeMap: TUnwrapExt;
 
@@ -161,7 +152,7 @@ export class GenericObjectSchema<
 
   write(
     output: ISerialOutput,
-    value: Parsed<UnwrapOfGeneric<TUnwrapBase, TUnwrapExt>>,
+    value: Parsed<UnwrapGeneric<TUnwrapBase, TUnwrapExt>>,
   ): void {
     // Figuring out sub-types
 
@@ -183,7 +174,7 @@ export class GenericObjectSchema<
     }
 
     // Writing the base properties
-    this._baseObject.write(output, value as Parsed<TUnwrapBase>);
+    this._baseObject.write(output, value as ParseUnwrappedRecord<TUnwrapBase>);
 
     // Extra sub-type fields
     for (const [key, extraProp] of exactEntries(
@@ -193,7 +184,7 @@ export class GenericObjectSchema<
     }
   }
 
-  read(input: ISerialInput): Parsed<UnwrapOfGeneric<TUnwrapBase, TUnwrapExt>> {
+  read(input: ISerialInput): Parsed<UnwrapGeneric<TUnwrapBase, TUnwrapExt>> {
     const subTypeKey =
       this.keyedBy === SubTypeKey.ENUM ? input.readByte() : input.readString();
 
@@ -208,7 +199,7 @@ export class GenericObjectSchema<
     }
 
     const result = this._baseObject.read(input) as Parsed<
-      UnwrapOfGeneric<TUnwrapBase, TUnwrapExt>
+      UnwrapGeneric<TUnwrapBase, TUnwrapExt>
     >;
 
     // Making the sub type key available to the result object.
@@ -228,10 +219,13 @@ export class GenericObjectSchema<
   }
 
   measure(
-    value: Parsed<UnwrapOfGeneric<TUnwrapBase, TUnwrapExt>> | MaxValue,
+    value: Parsed<UnwrapGeneric<TUnwrapBase, TUnwrapExt>> | MaxValue,
     measurer: IMeasurer = new Measurer(),
   ): IMeasurer {
-    this._baseObject.measure(value as Parsed<TUnwrapBase> | MaxValue, measurer);
+    this._baseObject.measure(
+      value as Parsed<UnwrapRecord<TUnwrapBase>> | MaxValue,
+      measurer,
+    );
 
     // We're a generic object trying to encode a concrete value.
     if (this.keyedBy === SubTypeKey.ENUM) {
diff --git a/src/structure/optional.ts b/src/structure/optional.ts
index 6a28de7..b9aa6eb 100644
--- a/src/structure/optional.ts
+++ b/src/structure/optional.ts
@@ -4,15 +4,15 @@ import {
   type ISerialInput,
   type ISerialOutput,
 } from '../io';
-import { Parsed } from '../utilityTypes';
-import { IRefResolver, MaxValue, Schema, AnySchema } from './types';
+import { ParseUnwrapped } from '../utilityTypes';
+import { IRefResolver, MaxValue, Schema, AnySchema, Unwrap } from './types';
 
-export class OptionalSchema<TUnwrap extends AnySchema> extends Schema<
-  TUnwrap | undefined
+export class OptionalSchema<TInner extends AnySchema> extends Schema<
+  Unwrap<TInner> | undefined
 > {
-  private innerSchema: TUnwrap;
+  private innerSchema: TInner;
 
-  constructor(private readonly _innerUnstableSchema: TUnwrap) {
+  constructor(private readonly _innerUnstableSchema: TInner) {
     super();
 
     // In case this optional isn't part of a keyed chain,
@@ -24,7 +24,10 @@ export class OptionalSchema<TUnwrap extends AnySchema> extends Schema<
     this.innerSchema = ctx.resolve(this._innerUnstableSchema);
   }
 
-  write(output: ISerialOutput, value: Parsed<TUnwrap> | undefined): void {
+  write(
+    output: ISerialOutput,
+    value: ParseUnwrapped<TInner> | undefined,
+  ): void {
     if (value !== undefined && value !== null) {
       output.writeBool(true);
       this.innerSchema.write(output, value);
@@ -33,18 +36,18 @@ export class OptionalSchema<TUnwrap extends AnySchema> extends Schema<
     }
   }
 
-  read(input: ISerialInput): Parsed<TUnwrap> | undefined {
+  read(input: ISerialInput): ParseUnwrapped<TInner> | undefined {
     const valueExists = input.readBool();
 
     if (valueExists) {
-      return this.innerSchema.read(input) as Parsed<TUnwrap>;
+      return this.innerSchema.read(input) as ParseUnwrapped<TInner>;
     }
 
     return undefined;
   }
 
   measure(
-    value: Parsed<TUnwrap> | MaxValue | undefined,
+    value: ParseUnwrapped<TInner> | MaxValue | undefined,
     measurer: IMeasurer = new Measurer(),
   ): IMeasurer {
     if (value !== undefined) {
diff --git a/src/structure/types.ts b/src/structure/types.ts
index 7ca2b65..2ce73b2 100644
--- a/src/structure/types.ts
+++ b/src/structure/types.ts
@@ -6,15 +6,59 @@ export const MaxValue = Symbol(
   'The biggest (in amount of bytes needed) value a schema can represent',
 );
 
-export type UnwrapOf<T> = T extends AnySchema ? T['__unwrapped'] : never;
-export type KeyDefinitionOf<T> = T extends AnySchema
-  ? T['__keyDefinition']
-  : never;
-
-export interface ISchemaWithProperties<
-  TUnwrap extends Record<string, AnySchema>,
-> extends ISchema<TUnwrap> {
-  readonly properties: TUnwrap;
+export interface IKeyedSchema<TUnwrap, TKeyDef extends string = string>
+  extends ISchema<TUnwrap> {
+  readonly __keyDefinition: TKeyDef;
+}
+
+/**
+ * Removes one layer of schema wrapping.
+ *
+ * @example ```
+ * Unwrap<ISchema<ISchema<number>>> -> ISchema<number>
+ * Unwrap<ISchema<number>> -> number
+ * ```
+ *
+ * Keyed schemas are bypassed.
+ *
+ * @example ```
+ * Unwrap<IKeyedSchema<ISchema<number>>> -> IKeyedSchema<number>
+ * ```
+ */
+export type Unwrap<T> = T extends IKeyedSchema<infer TInner, infer TKeyDef>
+  ? // bypassing keyed schemas, as that information has to be preserved for parsing
+    IKeyedSchema<Unwrap<TInner>, TKeyDef>
+  : T extends ISchema<infer TInner>
+  ? TInner
+  : T;
+
+/**
+ * Removes one layer of schema wrapping of record properties.
+ *
+ * @example ```
+ * Unwrap<{
+ *   a: ISchema<number>,
+ *   b: ISchema<ISchema<string>>
+ * }>
+ * // <=>
+ * {
+ *   a: number,
+ *   b: ISchema<string>
+ * }
+ * ```
+ */
+export type UnwrapRecord<T> = T extends IKeyedSchema<
+  Record<infer K, any>,
+  infer TKeyDef
+>
+  ? IKeyedSchema<{ [key in K]: Unwrap<T['__unwrapped'][key]> }, TKeyDef>
+  : T extends Record<infer K, any>
+  ? { [key in K]: Unwrap<T[key]> }
+  : T;
+
+export interface ISchemaWithProperties<TProps extends Record<string, AnySchema>>
+  extends ISchema<UnwrapRecord<TProps>> {
+  readonly properties: TProps;
 }
 
 export type AnySchemaWithProperties = ISchemaWithProperties<
@@ -29,40 +73,42 @@ export type PropertyDescription = {
 /**
  * @param TUnwrap one level of unwrapping to the inferred type.
  */
-export interface ISchema<TUnwrap, TKeyDef extends string = string> {
-  readonly __unwrapped: TUnwrap;
-  readonly __keyDefinition: TKeyDef;
+export interface ISchema<TUnwrapped> {
+  readonly __unwrapped: TUnwrapped;
+
   resolve(ctx: IRefResolver): void;
-  write(output: ISerialOutput, value: Parsed<TUnwrap>): void;
-  read(input: ISerialInput): Parsed<TUnwrap>;
-  measure(value: Parsed<TUnwrap> | MaxValue, measurer?: IMeasurer): IMeasurer;
+  write(output: ISerialOutput, value: Parsed<TUnwrapped>): void;
+  read(input: ISerialInput): Parsed<TUnwrapped>;
+  measure(
+    value: Parsed<TUnwrapped> | MaxValue,
+    measurer?: IMeasurer,
+  ): IMeasurer;
   seekProperty(
-    reference: Parsed<TUnwrap> | MaxValue,
-    prop: keyof TUnwrap,
+    reference: Parsed<TUnwrapped> | MaxValue,
+    prop: keyof TUnwrapped,
   ): PropertyDescription | null;
 }
 
 export type AnySchema = ISchema<unknown>;
 
-export abstract class Schema<TUnwrap> implements ISchema<TUnwrap, never> {
-  readonly __unwrapped!: TUnwrap;
-  readonly __keyDefinition!: never;
+export abstract class Schema<TUnwrapped> implements ISchema<TUnwrapped> {
+  readonly __unwrapped!: TUnwrapped;
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   resolve(ctx: IRefResolver): void {
     // override this if you need to resolve internal references.
   }
-  abstract write(output: ISerialOutput, value: Parsed<TUnwrap>): void;
-  abstract read(input: ISerialInput): Parsed<TUnwrap>;
+  abstract write(output: ISerialOutput, value: Parsed<TUnwrapped>): void;
+  abstract read(input: ISerialInput): Parsed<TUnwrapped>;
   abstract measure(
-    value: Parsed<TUnwrap> | MaxValue,
+    value: Parsed<TUnwrapped> | MaxValue,
     measurer?: IMeasurer,
   ): IMeasurer;
   seekProperty(
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _reference: Parsed<TUnwrap> | MaxValue,
+    _reference: Parsed<TUnwrapped> | MaxValue,
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _prop: keyof TUnwrap,
+    _prop: keyof TUnwrapped,
   ): PropertyDescription | null {
     // override this if necessary.
     return null;
@@ -86,7 +132,7 @@ export interface IRefResolver {
   hasKey(key: string): boolean;
 
   resolve<TSchema extends AnySchema>(schemaOrRef: TSchema): TSchema;
-  register<K extends string>(key: K, schema: ISchema<unknown, K>): void;
+  register<K extends string>(key: K, schema: ISchema<unknown>): void;
 }
 
 ////
diff --git a/src/utilityTypes.ts b/src/utilityTypes.ts
index d73d0ca..100cb0d 100644
--- a/src/utilityTypes.ts
+++ b/src/utilityTypes.ts
@@ -1,4 +1,10 @@
-import { ISchema, Ref, UnwrapOf } from './structure/types';
+import {
+  IKeyedSchema,
+  ISchema,
+  Ref,
+  Unwrap,
+  UnwrapRecord,
+} from './structure/types';
 
 /**
  * @example ```
@@ -44,16 +50,16 @@ export type Parsed<
     string,
     never
   >,
-> = T extends ISchema<infer TUnwrap, never>
-  ? // A non-keyed schema
-    Parsed<TUnwrap, TKeyDict>
-  : T extends ISchema<infer TUnwrap, infer TKeyDefinition>
+> = T extends IKeyedSchema<infer TUnwrapped, infer TKeyDefinition>
   ? // A schema that defines themselves under a key in the dictionary
-    Parsed<TUnwrap, TKeyDict & { [key in TKeyDefinition]: T }>
+    Parsed<TUnwrapped, TKeyDict & { [key in TKeyDefinition]: T }>
+  : T extends ISchema<infer TUnwrapped>
+  ? // A non-keyed schema
+    Parsed<TUnwrapped, TKeyDict>
   : // A reference to a keyed schema
   T extends Ref<infer K>
   ? K extends keyof TKeyDict
-    ? Parsed<UnwrapOf<TKeyDict[K]>, TKeyDict>
+    ? Parsed<Unwrap<TKeyDict[K]>, TKeyDict>
     : never
   : // Compound types
   T extends Record<string, unknown>
@@ -61,3 +67,7 @@ export type Parsed<
   : T extends (infer E)[]
   ? Parsed<E, TKeyDict>[]
   : T;
+
+export type ParseUnwrapped<T> = Parsed<Unwrap<T>>;
+
+export type ParseUnwrappedRecord<T> = Parsed<UnwrapRecord<T>>;