Use interface instead of type for all Base types

library/src/error/flatten/flatten.ts

@@ -78,7 +78,7 @@ type NestedPath<TSchema extends BaseSchema | BaseSchemaAsync> =
     TSchema extends
         | ObjectSchema<infer TEntries, infer TRest>
         | ObjectSchemaAsync<infer TEntries, infer TRest>
-    ? TRest extends BaseSchema | BaseSchemaAsync
+    ? TRest extends NonNullable<TRest>
       ? ObjectPath<TEntries> | DotPath<string, TRest>
       : ObjectPath<TEntries>
     : // Record
@@ -102,7 +102,7 @@ type NestedPath<TSchema extends BaseSchema | BaseSchemaAsync> =
     TSchema extends
         | TupleSchema<infer TItems, infer TRest>
         | TupleSchemaAsync<infer TItems, infer TRest>
-    ? TRest extends BaseSchema | BaseSchemaAsync
+    ? TRest extends NonNullable<TRest>
       ? TuplePath<TItems> | DotPath<number, TRest>
       : TuplePath<TItems>
     : // Union

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

@@ -1,10 +1,4 @@
-import type {
-  ObjectEntries,
-  ObjectSchema,
-  TupleItems,
-  TupleSchema,
-} from '../../schemas/index.ts';
-import type { BaseSchema } from '../../types/index.ts';
+import { isObjectSchema, isTupleSchema } from '../../schemas/index.ts';
 import {
   getDefault,
   type SchemaWithMaybeDefault,
@@ -22,36 +16,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;
-
+export function getDefaults<TSchema extends SchemaWithMaybeDefault>(
+  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 (isObjectSchema(schema)) {
+    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 (isTupleSchema(schema)) {
+    return schema.items.map(getDefaults) as DefaultValues<TSchema>;
   }
-
-  // Return default values
-  return defaults;
 }

library/src/methods/getDefaults/getDefaultsAsync.ts

@@ -1,14 +1,4 @@
-import type {
-  ObjectEntries,
-  ObjectEntriesAsync,
-  ObjectSchema,
-  ObjectSchemaAsync,
-  TupleItems,
-  TupleItemsAsync,
-  TupleSchema,
-  TupleSchemaAsync,
-} from '../../schemas/index.ts';
-import type { BaseSchema, BaseSchemaAsync } from '../../types/index.ts';
+import { isObjectSchema, isTupleSchema } from '../../schemas/index.ts';
 import {
   getDefaultAsync,
   type SchemaWithMaybeDefault,
@@ -28,43 +18,28 @@ import type { DefaultValues } from './types.ts';
  * @returns The default values.
  */
 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;
-
+  TSchema extends SchemaWithMaybeDefault | SchemaWithMaybeDefaultAsync
+>(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 (isObjectSchema(schema)) {
+    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 (isTupleSchema(schema)) {
+    return Promise.all(
+      schema.items.map(getDefaultsAsync)
+    ) as DefaultValues<TSchema>;
   }
-
-  // Return default values
-  return defaults;
 }

library/src/methods/getFallback/getFallback.ts

@@ -1,17 +1,5 @@
-import type { BaseSchema, Output } from '../../types/index.ts';
 import type { FallbackInfo } from '../fallback/types.ts';
-import type { FallbackValue } from './types.ts';
-
-/**
- * Schema with maybe fallback type.
- */
-export type SchemaWithMaybeFallback<TSchema extends BaseSchema = BaseSchema> =
-  TSchema & {
-    /**
-     * The optional fallback value.
-     */
-    fallback?: Output<TSchema> | ((info?: FallbackInfo) => Output<TSchema>);
-  };
+import type { FallbackValue, SchemaWithMaybeFallback } from './types.ts';
 
 /**
  * Returns the fallback value of the schema.

library/src/methods/getFallback/getFallbackAsync.ts

@@ -1,21 +1,9 @@
-import type { BaseSchemaAsync, Output } from '../../types/index.ts';
 import type { FallbackInfo } from '../fallback/types.ts';
-import type { SchemaWithMaybeFallback } from './getFallback.ts';
-import type { FallbackValue } from './types.ts';
-
-/**
- * Schema with maybe fallback async type.
- */
-export type SchemaWithMaybeFallbackAsync<
-  TSchema extends BaseSchemaAsync = BaseSchemaAsync
-> = TSchema & {
-  /**
-   * The optional fallback value.
-   */
-  fallback?:
-    | Output<TSchema>
-    | ((info?: FallbackInfo) => Output<TSchema> | Promise<Output<TSchema>>);
-};
+import type {
+  FallbackValue,
+  SchemaWithMaybeFallback,
+  SchemaWithMaybeFallbackAsync,
+} from './types.ts';
 
 /**
  * Returns the fallback value of the schema.

library/src/methods/getFallback/types.ts

@@ -1,6 +1,27 @@
-import type { Output } from '../../types/index.ts';
-import type { SchemaWithMaybeFallback } from './getFallback.ts';
-import type { SchemaWithMaybeFallbackAsync } from './getFallbackAsync.ts';
+import type { BaseSchema, BaseSchemaAsync, Output } from '../../types/index.ts';
+import type { FallbackInfo } from '../fallback/types.ts';
+
+/**
+ * Schema with maybe fallback type.
+ */
+export interface SchemaWithMaybeFallback<TInput = any, TOutput = TInput>
+  extends BaseSchema<TInput, TOutput> {
+  /**
+   * The optional fallback value.
+   */
+  fallback?: TOutput | ((info?: FallbackInfo) => TOutput);
+}
+
+/**
+ * Schema with maybe fallback async type.
+ */
+export interface SchemaWithMaybeFallbackAsync<TInput = any, TOutput = TInput>
+  extends BaseSchemaAsync<TInput, TOutput> {
+  /**
+   * The optional fallback value.
+   */
+  fallback?: TOutput | ((info?: FallbackInfo) => TOutput | Promise<TOutput>);
+}
 
 /**
  * Fallback value inference type.