diff --git a/example/server.ts b/example/server.ts
index f40701d..bc1d9d6 100644
--- a/example/server.ts
+++ b/example/server.ts
@@ -209,4 +209,4 @@ const app = new Elysia()
 	})
 	.listen(8080)
 
-export type Server = typeof app
+export type Server = typeof app
\ No newline at end of file
diff --git a/src/fetch/types.ts b/src/fetch/types.ts
index 58e6e2d..0531736 100644
--- a/src/fetch/types.ts
+++ b/src/fetch/types.ts
@@ -5,7 +5,8 @@ import type {
 	IsUnknown,
 	IsNever,
 	Prettify,
-	TreatyToPath
+	TreatyToPath,
+	JSONSerialized
 } from '../types'
 
 export namespace EdenFetch {
@@ -13,11 +14,11 @@ export namespace EdenFetch {
 		App extends {
 			'~Routes': infer Schema extends Record<string, unknown>
 		}
-			? EdenFetch.Fn<
-					// @ts-expect-error
-					TreatyToPath<Schema>
-				>
-			: 'Please install Elysia before using Eden'
+		? EdenFetch.Fn<
+			// @ts-expect-error
+			TreatyToPath<Schema>
+		>
+		: 'Please install Elysia before using Eden'
 
 	export interface Config extends RequestInit {
 		fetcher?: typeof globalThis.fetch
@@ -32,55 +33,55 @@ export namespace EdenFetch {
 		options: Omit<RequestInit, 'body' | 'method' | 'headers'> &
 			('GET' extends Method
 				? {
-						method?: Method
-					}
+					method?: Method
+				}
 				: {
-						method: Method
-					}) &
+					method: Method
+				}) &
 			(IsNever<keyof Route['params']> extends true
 				? {
-						params?: Record<never, string>
-					}
+					params?: Record<never, string>
+				}
 				: {
-						params: Route['params']
-					}) &
+					params: Route['params']
+				}) &
 			(IsNever<keyof Route['query']> extends true
 				? {
-						query?: Record<never, string>
-					}
+					query?: Record<never, string>
+				}
 				: {
-						query: Route['query']
-					}) &
+					query: Route['query']
+				}) &
 			(undefined extends Route['headers']
 				? {
-						headers?: Record<string, string>
-					}
+					headers?: Record<string, string>
+				}
 				: {
-						headers: Route['headers']
-					}) &
+					headers: Route['headers']
+				}) &
 			(IsUnknown<Route['body']> extends false
 				? { body: Route['body'] }
 				: { body?: unknown })
 	) => Promise<
 		Prettify<
 			| {
-					data: Awaited<Route['response'][200]>
-					error: null
-					status: number
-					headers: Record<string, unknown>
-					retry(): Promise<void>
-			  }
+				data: JSONSerialized<Awaited<Route['response'][200]>>
+				error: null
+				status: number
+				headers: Record<string, unknown>
+				retry(): Promise<void>
+			}
 			| {
-					data: null
-					error: MapError<Route['response']> extends infer Errors
-						? IsNever<Errors> extends true
-							? EdenFetchError<number, string>
-							: Errors
-						: EdenFetchError<number, string>
-					status: number
-					headers: Record<string, unknown>
-					retry(): Promise<void>
-			  }
+				data: null
+				error: MapError<Route['response']> extends infer Errors
+				? IsNever<Errors> extends true
+				? EdenFetchError<number, string>
+				: Errors
+				: EdenFetchError<number, string>
+				status: number
+				headers: Record<string, unknown>
+				retry(): Promise<void>
+			}
 		>
 	>
 }
diff --git a/src/treaty/types.ts b/src/treaty/types.ts
index 678c3c3..7821f68 100644
--- a/src/treaty/types.ts
+++ b/src/treaty/types.ts
@@ -1,15 +1,15 @@
 /// <reference lib="dom" />
 import { Elysia } from 'elysia'
 import type { EdenWS } from './index'
-import type { IsUnknown, IsNever, MapError, Prettify } from '../types'
+import type { IsUnknown, IsNever, MapError, Prettify, JSONSerialized } from '../types'
 import type { EdenFetchError } from '../errors'
 
 type Files = File | FileList
 
 type Replace<RecordType, TargetType, GenericType> = {
     [K in keyof RecordType]: RecordType[K] extends TargetType
-        ? GenericType
-        : RecordType[K]
+    ? GenericType
+    : RecordType[K]
 }
 
 type MaybeArray<T> = T | T[]
@@ -25,103 +25,105 @@ export namespace EdenTreaty {
 
     export type Sign<Route extends Record<string, any>> = {
         [K in keyof Route as K extends `:${string}`
-            ? (string & {}) | number | K
-            : K extends '' | '/'
-            ? 'index'
-            : K]: Route[K] extends {
+        ? (string & {}) | number | K
+        : K extends '' | '/'
+        ? 'index'
+        : K]: Route[K] extends {
             body: infer Body
             headers: infer Headers
             query: infer Query
             params: unknown
             response: infer Response
         }
-            ? K extends 'subscribe'
-                ? // ? Websocket route
-                  undefined extends Route['query']
-                    ? (params?: {
-                          $query?: Record<string, string>
-                      }) => EdenWS<Route>
-                    : (params: { $query: Route['query'] }) => EdenWS<Route['subscribe']>
-                : // ? HTTP route
-                ((
-                      params: Prettify<
-                          {
-                              $fetch?: RequestInit
-                              getRaw?: boolean
-                              $transform?: Transform
-                          } & (IsUnknown<Body> extends false
-                              ? Replace<Body, Blob | Blob[], Files>
-                              : {}) &
-                              (undefined extends Query
-                                  ? {
-                                        $query?: Record<string, string>
-                                    }
-                                  : {
-                                        $query: Query
-                                    }) &
-                              (undefined extends Headers
-                                  ? {
-                                        $headers?: Record<string, unknown>
-                                    }
-                                  : {
-                                        $headers: Headers
-                                    })
-                      >
-                  ) => Promise<
-                      (
-                          | {
-                                data: Response extends {
-                                    200: infer ReturnedType
-                                }
-                                    ? Awaited<ReturnedType>
-                                    : unknown
-                                error: null
-                            }
-                          | {
-                                data: null
-                                error: Response extends Record<number, unknown>
-                                    ? MapError<Response> extends infer Errors
-                                        ? IsNever<Errors> extends true
-                                            ? EdenFetchError<number, string>
-                                            : Errors
-                                        : EdenFetchError<number, string>
-                                    : EdenFetchError<number, unknown>
-                            }
-                      ) & {
-                          status: number
-                          response: Response
-                          headers: Record<string, string>
-                      }
-                  >) extends (params: infer Params) => infer Response
-                ? {
-                      $params: undefined
-                      $headers: undefined
-                      $query: undefined
-                  } extends Params
-                    ? (
-                          params?: Params,
-                          options?: {
-                              fetch?: RequestInit
-                              transform?: EdenTreaty.Transform<Response>
-                              // @ts-ignore
-                              query?: Params['query']
-                              // @ts-ignore
-                              headers?: Params['headers']
-                          }
-                      ) => Response
-                    : (
-                          params: Params,
-                          options?: {
-                              fetch?: RequestInit
-                              transform?: EdenTreaty.Transform<Response>
-                              // @ts-ignore
-                              query?: Params['query']
-                              // @ts-ignore
-                              headers?: Params['headers']
-                          }
-                      ) => Response
-                : never
-            : Prettify<Sign<Route[K]>>
+        ? K extends 'subscribe'
+        ? // ? Websocket route
+        undefined extends Route['query']
+        ? (params?: {
+            $query?: Record<string, string>
+        }) => EdenWS<Route>
+        : (params: { $query: Route['query'] }) => EdenWS<Route['subscribe']>
+        : // ? HTTP route
+        ((
+            params: Prettify<
+                {
+                    $fetch?: RequestInit
+                    getRaw?: boolean
+                    $transform?: Transform
+                } & (IsUnknown<Body> extends false
+                    ? Replace<Body, Blob | Blob[], Files>
+                    : {}) &
+                (undefined extends Query
+                    ? {
+                        $query?: Record<string, string>
+                    }
+                    : {
+                        $query: Query
+                    }) &
+                (undefined extends Headers
+                    ? {
+                        $headers?: Record<string, unknown>
+                    }
+                    : {
+                        $headers: Headers
+                    })
+            >
+        ) => Promise<
+            (
+                | {
+                    data: JSONSerialized<
+                        Response extends {
+                            200: infer ReturnedType
+                        }
+                        ? Awaited<ReturnedType>
+                        : unknown
+                    >
+                    error: null
+                }
+                | {
+                    data: null
+                    error: Response extends Record<number, unknown>
+                    ? MapError<Response> extends infer Errors
+                    ? IsNever<Errors> extends true
+                    ? EdenFetchError<number, string>
+                    : Errors
+                    : EdenFetchError<number, string>
+                    : EdenFetchError<number, unknown>
+                }
+            ) & {
+                status: number
+                response: Response
+                headers: Record<string, string>
+            }
+        >) extends (params: infer Params) => infer Response
+        ? {
+            $params: undefined
+            $headers: undefined
+            $query: undefined
+        } extends Params
+        ? (
+            params?: Params,
+            options?: {
+                fetch?: RequestInit
+                transform?: EdenTreaty.Transform<Response>
+                // @ts-ignore
+                query?: Params['query']
+                // @ts-ignore
+                headers?: Params['headers']
+            }
+        ) => Response
+        : (
+            params: Params,
+            options?: {
+                fetch?: RequestInit
+                transform?: EdenTreaty.Transform<Response>
+                // @ts-ignore
+                query?: Params['query']
+                // @ts-ignore
+                headers?: Params['headers']
+            }
+        ) => Response
+        : never
+        : Prettify<Sign<Route[K]>>
     }
 
     type UnwrapPromise<T> = T extends Promise<infer A> ? A : T
@@ -130,12 +132,12 @@ export namespace EdenTreaty {
         (
             response: unknown extends T
                 ? {
-                      data: any
-                      error: any
-                      response: Response
-                      status: number
-                      headers: Headers
-                  }
+                    data: any
+                    error: any
+                    response: Response
+                    status: number
+                    headers: Headers
+                }
                 : UnwrapPromise<T>
         ) => UnwrapPromise<T> | void
     >
diff --git a/src/treaty2/types.ts b/src/treaty2/types.ts
index bd21178..38e1287 100644
--- a/src/treaty2/types.ts
+++ b/src/treaty2/types.ts
@@ -2,7 +2,7 @@
 import type { Elysia, ELYSIA_FORM_DATA } from 'elysia'
 
 import { EdenWS } from './ws'
-import type { IsNever, MaybeEmptyObject, Not, Prettify } from '../types'
+import type { IsNever, MaybeEmptyObject, Not, Prettify, JSONSerialized } from '../types'
 
 // type Files = File | FileList
 
@@ -14,30 +14,30 @@ import type { IsNever, MaybeEmptyObject, Not, Prettify } from '../types'
 
 type And<A extends boolean, B extends boolean> = A extends true
     ? B extends true
-        ? true
-        : false
+    ? true
+    : false
     : false
 
 type ReplaceGeneratorWithAsyncGenerator<
     in out RecordType extends Record<string, unknown>
 > = {
     [K in keyof RecordType]: IsNever<RecordType[K]> extends true
-        ? RecordType[K]
-        : RecordType[K] extends Generator<infer A, infer B, infer C>
-          ? void extends B
-              ? AsyncGenerator<A, B, C>
-              : And<IsNever<A>, void extends B ? false : true> extends true
-                ? B
-                : AsyncGenerator<A, B, C> | B
-          : RecordType[K] extends AsyncGenerator<infer A, infer B, infer C>
-            ? And<Not<IsNever<A>>, void extends B ? true : false> extends true
-                ? AsyncGenerator<A, B, C>
-                : And<IsNever<A>, void extends B ? false : true> extends true
-                  ? B
-                  : AsyncGenerator<A, B, C> | B
-            : RecordType[K] extends ReadableStream<infer A>
-              ? AsyncGenerator<A, void, unknown>
-              : RecordType[K]
+    ? RecordType[K]
+    : RecordType[K] extends Generator<infer A, infer B, infer C>
+    ? void extends B
+    ? AsyncGenerator<A, B, C>
+    : And<IsNever<A>, void extends B ? false : true> extends true
+    ? B
+    : AsyncGenerator<A, B, C> | B
+    : RecordType[K] extends AsyncGenerator<infer A, infer B, infer C>
+    ? And<Not<IsNever<A>>, void extends B ? true : false> extends true
+    ? AsyncGenerator<A, B, C>
+    : And<IsNever<A>, void extends B ? false : true> extends true
+    ? B
+    : AsyncGenerator<A, B, C> | B
+    : RecordType[K] extends ReadableStream<infer A>
+    ? AsyncGenerator<A, void, unknown>
+    : RecordType[K]
 } & {}
 
 type Enumerate<
@@ -67,110 +67,110 @@ export namespace Treaty {
         App extends {
             '~Routes': infer Schema extends Record<any, any>
         }
-            ? Prettify<Sign<Schema>> & CreateParams<Schema>
-            : 'Please install Elysia before using Eden'
+        ? Prettify<Sign<Schema>> & CreateParams<Schema>
+        : 'Please install Elysia before using Eden'
 
     export type Sign<in out Route extends Record<any, any>> = {
         [K in keyof Route as K extends `:${string}`
-            ? never
-            : K]: K extends 'subscribe' // ? Websocket route
-            ? MaybeEmptyObject<Route['subscribe']['headers'], 'headers'> &
-                  MaybeEmptyObject<
-                      Route['subscribe']['query'],
-                      'query'
-                  > extends infer Param
-                ? (options?: Param) => EdenWS<Route['subscribe']>
-                : never
-            : Route[K] extends {
-                    body: infer Body
-                    headers: infer Headers
-                    params: any
-                    query: infer Query
-                    response: infer Res extends Record<number, unknown>
-                }
-              ? MaybeEmptyObject<Headers, 'headers'> &
-                    MaybeEmptyObject<Query, 'query'> extends infer Param
-                  ? {} extends Param
-                      ? undefined extends Body
-                          ? K extends 'get' | 'head'
-                              ? (
-                                    options?: Prettify<Param & TreatyParam>
-                                ) => Promise<
-                                    TreatyResponse<
-                                        ReplaceGeneratorWithAsyncGenerator<Res>
-                                    >
-                                >
-                              : (
-                                    body?: Body,
-                                    options?: Prettify<Param & TreatyParam>
-                                ) => Promise<
-                                    TreatyResponse<
-                                        ReplaceGeneratorWithAsyncGenerator<Res>
-                                    >
-                                >
-                          : K extends 'get' | 'head'
-                            ? (
-                                  options?: Prettify<Param & TreatyParam>
-                              ) => Promise<
-                                  TreatyResponse<
-                                      ReplaceGeneratorWithAsyncGenerator<Res>
-                                  >
-                              >
-                            : {} extends Body
-                              ? (
-                                    body?: Body,
-                                    options?: Prettify<Param & TreatyParam>
-                                ) => Promise<
-                                    TreatyResponse<
-                                        ReplaceGeneratorWithAsyncGenerator<Res>
-                                    >
-                                >
-                              : (
-                                    body: Body,
-                                    options?: Prettify<Param & TreatyParam>
-                                ) => Promise<
-                                    TreatyResponse<
-                                        ReplaceGeneratorWithAsyncGenerator<Res>
-                                    >
-                                >
-                      : K extends 'get' | 'head'
-                        ? (
-                              options: Prettify<Param & TreatyParam>
-                          ) => Promise<
-                              TreatyResponse<
-                                  ReplaceGeneratorWithAsyncGenerator<Res>
-                              >
-                          >
-                        : (
-                              body: Body,
-                              options: Prettify<Param & TreatyParam>
-                          ) => Promise<
-                              TreatyResponse<
-                                  ReplaceGeneratorWithAsyncGenerator<Res>
-                              >
-                          >
-                  : never
-              : CreateParams<Route[K]>
+        ? never
+        : K]: K extends 'subscribe' // ? Websocket route
+        ? MaybeEmptyObject<Route['subscribe']['headers'], 'headers'> &
+        MaybeEmptyObject<
+            Route['subscribe']['query'],
+            'query'
+        > extends infer Param
+        ? (options?: Param) => EdenWS<Route['subscribe']>
+        : never
+        : Route[K] extends {
+            body: infer Body
+            headers: infer Headers
+            params: any
+            query: infer Query
+            response: infer Res extends Record<number, unknown>
+        }
+        ? MaybeEmptyObject<Headers, 'headers'> &
+        MaybeEmptyObject<Query, 'query'> extends infer Param
+        ? {} extends Param
+        ? undefined extends Body
+        ? K extends 'get' | 'head'
+        ? (
+            options?: Prettify<Param & TreatyParam>
+        ) => Promise<
+            TreatyResponse<
+                ReplaceGeneratorWithAsyncGenerator<Res>
+            >
+        >
+        : (
+            body?: Body,
+            options?: Prettify<Param & TreatyParam>
+        ) => Promise<
+            TreatyResponse<
+                ReplaceGeneratorWithAsyncGenerator<Res>
+            >
+        >
+        : K extends 'get' | 'head'
+        ? (
+            options?: Prettify<Param & TreatyParam>
+        ) => Promise<
+            TreatyResponse<
+                ReplaceGeneratorWithAsyncGenerator<Res>
+            >
+        >
+        : {} extends Body
+        ? (
+            body?: Body,
+            options?: Prettify<Param & TreatyParam>
+        ) => Promise<
+            TreatyResponse<
+                ReplaceGeneratorWithAsyncGenerator<Res>
+            >
+        >
+        : (
+            body: Body,
+            options?: Prettify<Param & TreatyParam>
+        ) => Promise<
+            TreatyResponse<
+                ReplaceGeneratorWithAsyncGenerator<Res>
+            >
+        >
+        : K extends 'get' | 'head'
+        ? (
+            options: Prettify<Param & TreatyParam>
+        ) => Promise<
+            TreatyResponse<
+                ReplaceGeneratorWithAsyncGenerator<Res>
+            >
+        >
+        : (
+            body: Body,
+            options: Prettify<Param & TreatyParam>
+        ) => Promise<
+            TreatyResponse<
+                ReplaceGeneratorWithAsyncGenerator<Res>
+            >
+        >
+        : never
+        : CreateParams<Route[K]>
     }
 
     type CreateParams<Route extends Record<string, any>> =
         Extract<keyof Route, `:${string}`> extends infer Path extends string
-            ? IsNever<Path> extends true
-                ? Prettify<Sign<Route>>
-                : // ! DO NOT USE PRETTIFY ON THIS LINE, OTHERWISE FUNCTION CALLING WILL BE OMITTED
-                  (((params: {
-                      [param in Path extends `:${infer Param}`
-                          ? Param extends `${infer Param}?`
-                              ? Param
-                              : Param
-                          : never]: string | number
-                  }) => Prettify<Sign<Route[Path]>> &
-                      CreateParams<Route[Path]>) &
-                      Prettify<Sign<Route>>) &
-                      (Path extends `:${string}?`
-                          ? CreateParams<Route[Path]>
-                          : {})
-            : never
+        ? IsNever<Path> extends true
+        ? Prettify<Sign<Route>>
+        : // ! DO NOT USE PRETTIFY ON THIS LINE, OTHERWISE FUNCTION CALLING WILL BE OMITTED
+        (((params: {
+            [param in Path extends `:${infer Param}`
+            ? Param extends `${infer Param}?`
+            ? Param
+            : Param
+            : never]: string | number
+        }) => Prettify<Sign<Route[Path]>> &
+            CreateParams<Route[Path]>) &
+            Prettify<Sign<Route>>) &
+        (Path extends `:${string}?`
+            ? CreateParams<Route[Path]>
+            : {})
+        : never
 
     export interface Config {
         fetch?: Omit<RequestInit, 'headers' | 'method'>
@@ -178,9 +178,9 @@ export namespace Treaty {
         headers?: MaybeArray<
             | RequestInit['headers']
             | ((
-                  path: string,
-                  options: RequestInit
-              ) => RequestInit['headers'] | void)
+                path: string,
+                options: RequestInit
+            ) => RequestInit['headers'] | void)
         >
         onRequest?: MaybeArray<
             (
@@ -198,37 +198,41 @@ export namespace Treaty {
 
     export type TreatyResponse<Res extends Record<number, unknown>> =
         | {
-              data: Res[Extract<keyof Res, SuccessCodeRange>] extends {
-                  [ELYSIA_FORM_DATA]: infer Data
-              }
-                  ? Data
-                  : Res[Extract<keyof Res, SuccessCodeRange>]
-              error: null
-              response: Response
-              status: number
-              headers: ResponseInit['headers']
-          }
+            data: JSONSerialized<
+                Res[Extract<keyof Res, SuccessCodeRange>] extends {
+                    [ELYSIA_FORM_DATA]: infer Data
+                }
+                ? Data
+                : Res[Extract<keyof Res, SuccessCodeRange>]
+            >
+            error: null
+            response: Response
+            status: number
+            headers: ResponseInit['headers']
+        }
         | {
-              data: null
-              error: Exclude<keyof Res, SuccessCodeRange> extends never
-                  ? {
-                        status: unknown
-                        value: unknown
-                    }
-                  : {
-                        [Status in keyof Res]: {
-                            status: Status
-                            value: Res[Status] extends {
-                                [ELYSIA_FORM_DATA]: infer Data
-                            }
-                                ? Data
-                                : Res[Status]
+            data: null
+            error: Exclude<keyof Res, SuccessCodeRange> extends never
+            ? {
+                status: unknown
+                value: unknown
+            }
+            : {
+                [Status in keyof Res]: {
+                    status: Status
+                    value: JSONSerialized<
+                        Res[Status] extends {
+                            [ELYSIA_FORM_DATA]: infer Data
                         }
-                    }[Exclude<keyof Res, SuccessCodeRange>]
-              response: Response
-              status: number
-              headers: ResponseInit['headers']
-          }
+                        ? Data
+                        : Res[Status]
+                    >
+                }
+            }[Exclude<keyof Res, SuccessCodeRange>]
+            response: Response
+            status: number
+            headers: ResponseInit['headers']
+        }
 
     export interface OnMessage<Data = unknown> extends MessageEvent {
         data: Data
diff --git a/src/types.ts b/src/types.ts
index 2011a9b..bae7605 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -21,8 +21,8 @@ export type MapError<T extends Record<number, unknown>> = [
     }[keyof T]
 ] extends [infer A extends number]
     ? {
-          [K in A]: EdenFetchError<K, T[K]>
-      }[A]
+        [K in A]: EdenFetchError<K, T[K]>
+    }[A]
     : false
 
 export type UnionToIntersect<U> = (
@@ -49,16 +49,16 @@ export type IsUnknown<T> = IsAny<T> extends true
 
 type IsExactlyUnknown<T> = [T] extends [unknown]
     ? [unknown] extends [T]
-        ? true
-        : false
+    ? true
+    : false
     : false;
 
 type IsUndefined<T> = [T] extends [undefined] ? true : false
 
 type IsMatchingEmptyObject<T> = [T] extends [{}]
     ? [{}] extends [T]
-        ? true
-        : false
+    ? true
+    : false
     : false
 
 export type MaybeEmptyObject<
@@ -91,14 +91,50 @@ export type Prettify<T> = {
 
 export type TreatyToPath<T, Path extends string = ''> = UnionToIntersect<
     T extends Record<string, unknown>
-        ? {
-              [K in keyof T]: T[K] extends AnyTypedRoute
-                  ? { [path in Path]: { [method in K]: T[K] } }
-                  : unknown extends T[K]
-                  ? { [path in Path]: { [method in K]: T[K] } }
-                  : TreatyToPath<T[K], `${Path}/${K & string}`>
-          }[keyof T]
-        : {}
+    ? {
+        [K in keyof T]: T[K] extends AnyTypedRoute
+        ? { [path in Path]: { [method in K]: T[K] } }
+        : unknown extends T[K]
+        ? { [path in Path]: { [method in K]: T[K] } }
+        : TreatyToPath<T[K], `${Path}/${K & string}`>
+    }[keyof T]
+    : {}
 >
 
 export type Not<T> = T extends true ? false : true
+
+/**
+ * Transforms a type to match its JSON.stringify() serialization behavior.
+ * This handles:
+ * - Objects with .toJSON() methods (e.g., DDD domain instances)
+ * - Date objects (converted to string)
+ * - Arrays (recursively serialized)
+ * - Objects (recursively serialized, excluding functions)
+ * - Primitives (unchanged)
+ *
+ * Special types like AsyncGenerator, Generator, ReadableStream, File, and Blob
+ * are preserved as-is since they're handled by other transformations or runtime.
+ */
+export type JSONSerialized<T> = T extends { toJSON(): infer R }
+    ? R extends () => infer U
+    ? JSONSerialized<U>
+    : JSONSerialized<R>
+    : T extends Date
+    ? string
+    : T extends Function
+    ? never
+    : T extends AsyncGenerator<infer A, infer B, infer C>
+    ? AsyncGenerator<A, B, C>
+    : T extends Generator<infer A, infer B, infer C>
+    ? Generator<A, B, C>
+    : T extends ReadableStream<infer R>
+    ? ReadableStream<R>
+    : T extends File
+    ? File
+    : T extends Blob
+    ? Blob
+    : T extends Array<infer U>
+    ? Array<JSONSerialized<U>>
+    : T extends object
+    ? { [K in keyof T as T[K] extends Function ? never : K]: JSONSerialized<T[K]> }
+    : T
\ No newline at end of file