Use interface instead of type for all Base types

library/src/error/flatten/flatten.ts

@@ -70,67 +70,56 @@ type NestedPath<TSchema extends BaseSchema | BaseSchemaAsync> =
         >
       ? DotPath<number, TItem>
       : // Map
-        TSchema extends MapSchema<infer TKey, infer TValue>
+        TSchema extends
+            | MapSchema<infer TKey, infer TValue>
+            | MapSchemaAsync<infer TKey, infer TValue>
         ? DotPath<Input<TKey>, TValue>
-        : TSchema extends MapSchemaAsync<infer TKey, infer TValue>
-          ? DotPath<Input<TKey>, TValue>
-          : // Object
-            TSchema extends ObjectSchema<infer TEntries, infer TRest>
-            ? TRest extends BaseSchema
-              ? ObjectPath<TEntries> | DotPath<string, TRest>
-              : ObjectPath<TEntries>
-            : TSchema extends ObjectSchemaAsync<infer TEntries, infer TRest>
-              ? TRest extends BaseSchema | BaseSchemaAsync
-                ? ObjectPath<TEntries> | DotPath<string, TRest>
-                : ObjectPath<TEntries>
-              : // Record
-                TSchema extends RecordSchema<infer TKey, infer TValue>
-                ? DotPath<Input<TKey>, TValue>
-                : TSchema extends RecordSchemaAsync<infer TKey, infer TValue>
-                  ? DotPath<Input<TKey>, TValue>
-                  : // Lazy
-                    TSchema extends LazySchema<
-                        infer TSchemaGetter extends () => BaseSchema
-                      >
-                    ? NestedPath<ReturnType<TSchemaGetter>>
-                    : TSchema extends LazySchemaAsync<
-                          infer TSchemaGetter extends () =>
-                            | BaseSchema
-                            | BaseSchemaAsync
+        : // Object
+          TSchema extends
+              | ObjectSchema<infer TEntries, infer TRest>
+              | ObjectSchemaAsync<infer TEntries, infer TRest>
+          ? TRest extends NonNullable<TRest>
+            ? ObjectPath<TEntries> | DotPath<string, TRest>
+            : ObjectPath<TEntries>
+          : // Record
+            TSchema extends
+                | RecordSchema<infer TKey, infer TValue>
+                | RecordSchemaAsync<infer TKey, infer TValue>
+            ? DotPath<Input<TKey>, TValue>
+            : // Lazy
+              TSchema extends LazySchema<
+                  infer TSchemaGetter extends () => BaseSchema
+                >
+              ? NestedPath<ReturnType<TSchemaGetter>>
+              : TSchema extends LazySchemaAsync<
+                    infer TSchemaGetter extends () =>
+                      | BaseSchema
+                      | BaseSchemaAsync
+                  >
+                ? NestedPath<ReturnType<TSchemaGetter>>
+                : // Set
+                  TSchema extends
+                      | SetSchema<infer TValue>
+                      | SetSchemaAsync<infer TValue>
+                  ? DotPath<number, TValue>
+                  : // Tuple
+                    TSchema extends
+                        | TupleSchema<infer TItems, infer TRest>
+                        | TupleSchemaAsync<infer TItems, infer TRest>
+                    ? TRest extends NonNullable<TRest>
+                      ? TuplePath<TItems> | DotPath<number, TRest>
+                      : TuplePath<TItems>
+                    : // Union
+                      TSchema extends UnionSchema<
+                          infer TUnionOptions extends UnionOptions
                         >
-                      ? NestedPath<ReturnType<TSchemaGetter>>
-                      : // Set
-                        TSchema extends SetSchema<infer TValue>
-                        ? DotPath<number, TValue>
-                        : TSchema extends SetSchemaAsync<infer TValue>
-                          ? DotPath<number, TValue>
-                          : // Tuple
-                            TSchema extends TupleSchema<
-                                infer TItems,
-                                infer TRest
-                              >
-                            ? TRest extends BaseSchema
-                              ? TuplePath<TItems> | DotPath<number, TRest>
-                              : TuplePath<TItems>
-                            : TSchema extends TupleSchemaAsync<
-                                  infer TItems,
-                                  infer TRest
-                                >
-                              ? TRest extends BaseSchema | BaseSchemaAsync
-                                ? TuplePath<TItems> | DotPath<number, TRest>
-                                : TuplePath<TItems>
-                              : // Union
-                                TSchema extends UnionSchema<
-                                    infer TUnionOptions extends UnionOptions
-                                  >
-                                ? NestedPath<TUnionOptions[number]>
-                                : TSchema extends UnionSchemaAsync<
-                                      infer TUnionOptions extends
-                                        UnionOptionsAsync
-                                    >
-                                  ? NestedPath<TUnionOptions[number]>
-                                  : // Otherwise
-                                    never;
+                      ? NestedPath<TUnionOptions[number]>
+                      : TSchema extends UnionSchemaAsync<
+                            infer TUnionOptions extends UnionOptionsAsync
+                          >
+                        ? NestedPath<TUnionOptions[number]>
+                        : // Otherwise
+                          never;
 
 /**
  * Flat errors type.

library/src/methods/fallback/fallback.ts

@@ -8,17 +8,13 @@ import type { FallbackInfo } from './types.ts';
 /**
  * Schema with fallback type.
  */
-export type SchemaWithFallback<
-  TSchema extends BaseSchema = BaseSchema,
-  TFallback extends
-    | Output<TSchema>
-    | ((info?: FallbackInfo) => Output<TSchema>) = Output<TSchema>,
-> = TSchema & {
+export interface SchemaWithFallback<TInput = any, TOutput = TInput>
+  extends BaseSchema<TInput, TOutput> {
   /**
    * The fallback value.
    */
-  fallback: TFallback;
-};
+  fallback: TOutput | ((info?: FallbackInfo) => TOutput);
+}
 
 /**
  * Returns a fallback output value when validating the passed schema failed.

library/src/methods/fallback/fallbackAsync.ts

@@ -6,19 +6,13 @@ import type { FallbackInfo } from './types.ts';
 /**
  * Schema with fallback async type.
  */
-export type SchemaWithFallbackAsync<
-  TSchema extends BaseSchemaAsync = BaseSchemaAsync,
-  TFallback extends
-    | Output<TSchema>
-    | ((
-        info?: FallbackInfo
-      ) => Output<TSchema> | Promise<Output<TSchema>>) = Output<TSchema>,
-> = TSchema & {
+export interface SchemaWithFallbackAsync<TInput = any, TOutput = TInput>
+  extends BaseSchemaAsync<TInput, TOutput> {
   /**
    * The fallback value.
    */
-  fallback: TFallback;
-};
+  fallback: TOutput | ((info?: FallbackInfo) => TOutput | Promise<TOutput>);
+}
 
 /**
  * Returns a fallback output value when validating the passed schema failed.

library/src/methods/getDefault/getDefault.ts

@@ -1,16 +1,4 @@
-import type { BaseSchema, Output } from '../../types/index.ts';
-import type { DefaultValue } from './types.ts';
-
-/**
- * Schema with maybe default type.
- */
-export type SchemaWithMaybeDefault<TSchema extends BaseSchema = BaseSchema> =
-  TSchema & {
-    /**
-     * The optional default value.
-     */
-    default?: Output<TSchema> | (() => Output<TSchema> | undefined);
-  };
+import type { DefaultValue, SchemaWithMaybeDefault } from './types.ts';
 
 /**
  * Returns the default value of the schema.

library/src/methods/getDefault/getDefaultAsync.ts

@@ -1,23 +1,8 @@
-import type { BaseSchemaAsync, Output } from '../../types/index.ts';
-import type { SchemaWithMaybeDefault } from './getDefault.ts';
-import type { DefaultValue } from './types.ts';
-
-/**
- * Schema with maybe default async type.
- */
-export type SchemaWithMaybeDefaultAsync<
-  TSchema extends BaseSchemaAsync = BaseSchemaAsync,
-> = TSchema & {
-  /**
-   * The optional default value.
-   */
-  default?:
-    | Output<TSchema>
-    | (() =>
-        | Output<TSchema>
-        | Promise<Output<TSchema> | undefined>
-        | undefined);
-};
+import type {
+  DefaultValue,
+  SchemaWithMaybeDefault,
+  SchemaWithMaybeDefaultAsync,
+} from './types.ts';
 
 /**
  * Returns the default value of the schema.

library/src/methods/getDefault/types.ts

@@ -1,6 +1,28 @@
-import type { Output } from '../../types/index.ts';
-import type { SchemaWithMaybeDefault } from './getDefault.ts';
-import type { SchemaWithMaybeDefaultAsync } from './getDefaultAsync.ts';
+import type { BaseSchema, BaseSchemaAsync, Output } from '../../types/index.ts';
+
+/**
+ * Schema with maybe default type.
+ */
+export interface SchemaWithMaybeDefault<TInput = any, TOutput = TInput>
+  extends BaseSchema<TInput, TOutput> {
+  /**
+   * The optional default value.
+   */
+  default?: TOutput | (() => TOutput | undefined);
+}
+
+/**
+ * Schema with maybe default async type.
+ */
+export interface SchemaWithMaybeDefaultAsync<TInput = any, TOutput = TInput>
+  extends BaseSchemaAsync<TInput, TOutput> {
+  /**
+   * The optional default value.
+   */
+  default?:
+    | TOutput
+    | (() => TOutput | Promise<TOutput | undefined> | undefined);
+}
 
 /**
  * Default value inference type.

library/src/methods/getDefaults/getDefaults.ts

@@ -4,7 +4,8 @@ import type {
   TupleItems,
   TupleSchema,
 } from '../../schemas/index.ts';
-import type { BaseSchema } from '../../types/index.ts';
+import type { BaseSchema } from '../../types/schema.ts';
+import { hasType } from '../../utils/index.ts';
 import {
   getDefault,
   type SchemaWithMaybeDefault,
@@ -23,35 +24,25 @@ import type { DefaultValues } from './types.ts';
  * @returns The default values.
  */
 export function getDefaults<
-  TSchema extends SchemaWithMaybeDefault<
-    BaseSchema | ObjectSchema<ObjectEntries, any> | TupleSchema<TupleItems, any>
-  >,
->(schema: TSchema): DefaultValues<TSchema> {
-  // Create defaults variable
-  let defaults: any;
-
+  TSchema extends SchemaWithMaybeDefault &
+    (BaseSchema | ObjectSchema<ObjectEntries> | TupleSchema<TupleItems>),
+>(schema: TSchema): DefaultValues<TSchema> | undefined {
   // If schema contains a default function, set its default value
   if (schema.default !== undefined) {
-    defaults = getDefault(schema);
-
-    // Otherwise, check if schema is of kind object or tuple
-  } else if ('type' in schema) {
-    // If it is an object schema, set object with default value of each entry
-    if (schema.type === 'object') {
-      defaults = {};
-      for (const key in schema.entries) {
-        defaults[key] = getDefaults(schema.entries[key]);
-      }
-
-      // If it is a tuple schema, set array with default value of each item
-    } else if (schema.type === 'tuple') {
-      defaults = [];
-      for (let key = 0; key < schema.items.length; key++) {
-        defaults.push(getDefaults(schema.items[key]));
-      }
-    }
+    return getDefault(schema);
+  }
+  // Otherwise, check if schema is of kind object or tuple
+  // If it is an object schema, set object with default value of each entry
+  if (hasType(schema, 'object')) {
+    return Object.fromEntries(
+      Object.entries(schema.entries).map(([key, value]) => [
+        key,
+        getDefaults(value),
+      ])
+    ) as DefaultValues<TSchema>;
+  }
+  // If it is a tuple schema, set array with default value of each item
+  if (hasType(schema, 'tuple')) {
+    return schema.items.map(getDefaults) as DefaultValues<TSchema>;
   }
-
-  // Return default values
-  return defaults;
 }

library/src/methods/getDefaults/getDefaultsAsync.ts

@@ -8,7 +8,8 @@ import type {
   TupleSchema,
   TupleSchemaAsync,
 } from '../../schemas/index.ts';
-import type { BaseSchema, BaseSchemaAsync } from '../../types/index.ts';
+import type { BaseSchema, BaseSchemaAsync } from '../../types/schema.ts';
+import { hasType } from '../../utils/index.ts';
 import {
   getDefaultAsync,
   type SchemaWithMaybeDefault,
@@ -29,42 +30,35 @@ import type { DefaultValues } from './types.ts';
  */
 export async function getDefaultsAsync<
   TSchema extends
-    | SchemaWithMaybeDefault<
-        | BaseSchema
-        | ObjectSchema<ObjectEntries, any>
-        | TupleSchema<TupleItems, any>
-      >
-    | SchemaWithMaybeDefaultAsync<
-        | BaseSchemaAsync
-        | ObjectSchemaAsync<ObjectEntriesAsync, any>
-        | TupleSchemaAsync<TupleItemsAsync, any>
-      >,
->(schema: TSchema): Promise<DefaultValues<TSchema>> {
-  // Create defaults variable
-  let defaults: any;
-
+    | (SchemaWithMaybeDefault &
+        (BaseSchema | ObjectSchema<ObjectEntries> | TupleSchema<TupleItems>))
+    | (SchemaWithMaybeDefaultAsync &
+        (
+          | BaseSchemaAsync
+          | ObjectSchemaAsync<ObjectEntriesAsync>
+          | TupleSchemaAsync<TupleItemsAsync>
+        )),
+>(schema: TSchema): Promise<DefaultValues<TSchema> | undefined> {
   // If schema contains a default function, set its default value
   if (schema.default !== undefined) {
-    defaults = await getDefaultAsync(schema);
-
-    // Otherwise, check if schema is of kind object or tuple
-  } else if ('type' in schema) {
-    // If it is an object schema, set object with default value of each entry
-    if (schema.type === 'object') {
-      defaults = {};
-      for (const key in schema.entries) {
-        defaults[key] = await getDefaultsAsync(schema.entries[key]);
-      }
-
-      // If it is a tuple schema, set array with default value of each item
-    } else if (schema.type === 'tuple') {
-      defaults = [];
-      for (let key = 0; key < schema.items.length; key++) {
-        defaults.push(await getDefaultsAsync(schema.items[key]));
-      }
-    }
+    return getDefaultAsync(schema);
+  }
+  // Otherwise, check if schema is of kind object or tuple
+  // If it is an object schema, set object with default value of each entry
+  if (hasType(schema, 'object')) {
+    return Object.fromEntries(
+      await Promise.all(
+        Object.entries(schema.entries).map(async ([key, value]) => [
+          key,
+          await getDefaultsAsync(value),
+        ])
+      )
+    );
+  }
+  // If it is a tuple schema, set array with default value of each item
+  if (hasType(schema, 'tuple')) {
+    return Promise.all(
+      schema.items.map(getDefaultsAsync)
+    ) as DefaultValues<TSchema>;
   }
-
-  // Return default values
-  return defaults;
 }