@navios/react-query 0.7.1 → 1.0.0

package/lib/index.d.cts

@@ -1,8 +1,8 @@
 import * as _navios_builder0 from "@navios/builder";
-import { AbstractEndpoint, AnyEndpointConfig, BaseEndpointConfig, BaseStreamConfig, BuilderInstance, EndpointFunctionArgs, HttpMethod, NaviosZodRequest, UrlHasParams, UrlParams, Util_FlatObject } from "@navios/builder";
-import * as _tanstack_react_query1 from "@tanstack/react-query";
-import { DataTag, InfiniteData, MutationFunctionContext, QueryClient, UseInfiniteQueryOptions, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult, UseSuspenseInfiniteQueryOptions, UseSuspenseQueryOptions, UseSuspenseQueryResult } from "@tanstack/react-query";
+import { AbstractEndpoint, AnyEndpointConfig, BaseEndpointConfig, BaseEndpointOptions, BuilderInstance, EndpointHandler, EndpointOptions, ErrorSchemaRecord, HttpMethod, InferEndpointParams, InferEndpointReturn, InferErrorSchemaOutput, RequestArgs, Simplify, StreamHandler, UrlHasParams, UrlParams } from "@navios/builder";
 import { ZodObject, ZodType, z } from "zod/v4";
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+import { DataTag, FetchQueryOptions, InfiniteData, MutationFunctionContext, QueryClient, QueryKey, UseInfiniteQueryOptions, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult, UseSuspenseInfiniteQueryOptions, UseSuspenseQueryOptions, UseSuspenseQueryResult } from "@tanstack/react-query";
 
 //#region src/common/types.d.mts
 /**
@@ -13,29 +13,66 @@ type Split<S extends string, D extends string> = string extends S ? string[] : S
 /**
  * Function type for processing API responses before returning to the caller.
  */
-type ProcessResponseFunction<TData = unknown, TVariables = unknown> = (variables: TVariables) => Promise<TData> | TData;
+type ProcessResponseFunction<TData$1 = unknown, TVariables = unknown> = (variables: TVariables) => Promise<TData$1> | TData$1;
+/**
+ * Compute the response input type based on discriminator and error schema.
+ * When UseDiscriminator=true and errorSchema is present, errors are included as a union.
+ * When UseDiscriminator=false, only the success type is returned (errors are thrown).
+ *
+ * @template UseDiscriminator - Whether to include error types in the response union
+ * @template ResponseSchema - The success response schema
+ * @template ErrorSchema - The error schema record (optional)
+ */
+type ComputeResponseInput<UseDiscriminator extends boolean, ResponseSchema extends ZodType, ErrorSchema extends ErrorSchemaRecord | undefined> = UseDiscriminator extends true ? ErrorSchema extends ErrorSchemaRecord ? z.output<ResponseSchema> | InferErrorSchemaOutput<ErrorSchema> : z.output<ResponseSchema> : z.output<ResponseSchema>;
 /**
  * Options for creating a client instance.
+ *
+ * @template UseDiscriminator - When `true`, errors are returned as union types.
+ *   When `false` (default), errors are thrown.
  */
-type ClientOptions = {
-  api: BuilderInstance;
+type ClientOptions<UseDiscriminator extends boolean = false> = {
+  api: BuilderInstance<UseDiscriminator>;
   defaults?: {
     keyPrefix?: string[];
     keySuffix?: string[];
   };
 };
+/**
+ * Infers the full response type from an endpoint configuration.
+ * Returns `ResponseType | ErrorTypes` if errorSchema exists,
+ * otherwise just `ResponseType`.
+ *
+ * @example
+ * ```ts
+ * type Response = InferEndpointResponse<{
+ *   responseSchema: z.ZodObject<{ data: z.ZodString }>,
+ *   errorSchema: { 400: z.ZodObject<{ error: z.ZodString }> }
+ * }>
+ * // Result: { data: string } | { error: string }
+ * ```
+ */
+type InferEndpointResponse<Config extends {
+  responseSchema: ZodType;
+  errorSchema?: ErrorSchemaRecord;
+}> = Config['errorSchema'] extends ErrorSchemaRecord ? z.output<Config['responseSchema']> | InferErrorSchemaOutput<Config['errorSchema']> : z.output<Config['responseSchema']>;
+/**
+ * Computes the Result type, applying processResponse transformation
+ * to the full response (including error union when present).
+ */
+type ComputeResultType<ResponseSchema extends ZodType, ErrorSchema extends ErrorSchemaRecord | undefined, ProcessedResult> = ProcessedResult extends undefined ? ErrorSchema extends ErrorSchemaRecord ? z.output<ResponseSchema> | InferErrorSchemaOutput<ErrorSchema> : z.output<ResponseSchema> : ProcessedResult;
 //#endregion
 //#region src/query/types.d.mts
+/**
+ * Helper type to extract the result type from processResponse.
+ */
+type QueryResult<Options extends EndpointOptions, UseDiscriminator extends boolean = false> = Options extends {
+  processResponse: (data: any) => infer Result;
+} ? Result : InferEndpointReturn<Options, UseDiscriminator>;
 /**
  * Arguments for query functions based on URL params and query schema.
+ * Uses RequestArgs from builder for consistency.
  */
-type QueryArgs<Url extends string = string, QuerySchema = ZodObject, RequestSchema = undefined> = (UrlHasParams<Url> extends true ? {
-  urlParams: UrlParams<Url>;
-} : {}) & (QuerySchema extends ZodObject ? {
-  params: z.input<QuerySchema>;
-} : {}) & (RequestSchema extends ZodType ? {
-  data: z.input<RequestSchema>;
-} : {});
+type QueryArgs<Url extends string = string, QuerySchema extends ZodObject | undefined = undefined, RequestSchema extends ZodType | undefined = undefined> = RequestArgs<Url, QuerySchema, RequestSchema>;
 /**
  * Arguments containing only URL params (for invalidateAll operations).
  */
@@ -44,12 +81,15 @@ type QueryUrlParamsArgs<Url extends string = string> = UrlHasParams<Url> extends
 } : {} | undefined;
 /**
  * Base parameters for query configuration.
+ *
+ * @template UseDiscriminator - When `true`, errors are returned as union types in processResponse.
+ *   When `false` (default), errors are thrown and not included in the response type.
  */
-type QueryParams<Config extends AnyEndpointConfig, Res = any> = {
+type QueryParams<Config extends AnyEndpointConfig, Res = any, UseDiscriminator extends boolean = false> = {
   keyPrefix?: string[];
   keySuffix?: string[];
   onFail?: (err: unknown) => void;
-  processResponse: (data: z.output<Config['responseSchema']>) => Res;
+  processResponse: (data: ComputeResponseInput<UseDiscriminator, Config['responseSchema'], Config['errorSchema']>) => Res;
 };
 /**
  * Result type from the query key creator function.
@@ -75,25 +115,28 @@ type QueryKeyCreatorResult<QuerySchema = undefined, Url extends string = string,
  */
 type QueryHelpers<Url extends string, QuerySchema extends ZodObject | undefined = undefined, Result$1 = undefined, IsInfinite extends boolean = false, RequestSchema extends ZodType | undefined = undefined> = {
   queryKey: QueryKeyCreatorResult<QuerySchema, Url, Result$1, IsInfinite>;
-  use: (params: Util_FlatObject<QueryArgs<Url, QuerySchema, RequestSchema>>) => UseQueryResult<Result$1, Error>;
-  useSuspense: (params: Util_FlatObject<QueryArgs<Url, QuerySchema, RequestSchema>>) => UseSuspenseQueryResult<Result$1, Error>;
-  invalidate: (queryClient: QueryClient, params: Util_FlatObject<QueryArgs<Url, QuerySchema, RequestSchema>>) => () => Promise<void>;
-  invalidateAll: (queryClient: QueryClient, params: Util_FlatObject<QueryUrlParamsArgs<Url>>) => () => Promise<void>;
+  use: (params: Simplify<QueryArgs<Url, QuerySchema, RequestSchema>>) => UseQueryResult<Result$1, Error>;
+  useSuspense: (params: Simplify<QueryArgs<Url, QuerySchema, RequestSchema>>) => UseSuspenseQueryResult<Result$1, Error>;
+  invalidate: (queryClient: QueryClient, params: Simplify<QueryArgs<Url, QuerySchema, RequestSchema>>) => () => Promise<void>;
+  invalidateAll: (queryClient: QueryClient, params: Simplify<QueryUrlParamsArgs<Url>>) => () => Promise<void>;
 };
 /**
  * Options for infinite query configuration.
+ *
+ * @template UseDiscriminator - When `true`, errors are returned as union types in processResponse.
+ *   When `false` (default), errors are thrown and not included in the response type.
  */
-type InfiniteQueryOptions<Config extends BaseEndpointConfig<HttpMethod, string, ZodObject>, Res = any> = {
+type InfiniteQueryOptions<Config extends BaseEndpointConfig<HttpMethod, string, ZodObject>, Res = any, UseDiscriminator extends boolean = false> = {
   keyPrefix?: string[];
   keySuffix?: string[];
-  processResponse: (data: z.infer<Config['responseSchema']>) => Res;
+  processResponse: (data: ComputeResponseInput<UseDiscriminator, Config['responseSchema'], Config['errorSchema']>) => Res;
   onFail?: (err: unknown) => void;
   getNextPageParam: (lastPage: Res, allPages: Res[], lastPageParam: z.infer<Config['querySchema']> | undefined, allPageParams: z.infer<Config['querySchema']>[] | undefined) => z.input<Config['querySchema']> | z.infer<Config['querySchema']> | undefined;
   getPreviousPageParam?: (firstPage: Res, allPages: Res[], lastPageParam: z.infer<Config['querySchema']> | undefined, allPageParams: z.infer<Config['querySchema']>[] | undefined) => z.input<Config['querySchema']>;
   initialPageParam?: z.input<Config['querySchema']> | z.infer<Config['querySchema']>;
 };
 /** @deprecated Use QueryArgs instead */
-type ClientQueryArgs<Url extends string = string, QuerySchema = ZodObject, RequestSchema = undefined> = QueryArgs<Url, QuerySchema, RequestSchema>;
+type ClientQueryArgs<Url extends string = string, QuerySchema extends ZodObject = ZodObject, RequestSchema extends ZodType | undefined = undefined> = QueryArgs<Url, QuerySchema, RequestSchema>;
 /** @deprecated Use QueryUrlParamsArgs instead */
 type ClientQueryUrlParamsArgs<Url extends string = string> = QueryUrlParamsArgs<Url>;
 /** @deprecated Use QueryParams instead */
@@ -122,25 +165,54 @@ declare function createQueryKey<Config extends AnyEndpointConfig, Options extend
 declare const queryKeyCreator: typeof createQueryKey;
 //#endregion
 //#region src/query/make-options.d.mts
+/**
+ * Options for makeQueryOptions.
+ */
+interface MakeQueryOptionsParams<Options extends EndpointOptions, UseDiscriminator extends boolean = false, Result$1 = QueryResult<Options, UseDiscriminator>> {
+  keyPrefix?: string[];
+  keySuffix?: string[];
+  onFail?: (err: unknown) => void;
+  processResponse: (data: InferEndpointReturn<Options, UseDiscriminator>) => Result$1;
+}
 /**
  * Creates query options for a given endpoint.
  *
  * Returns a function that generates TanStack Query options when called with params.
  * The returned function also has helper methods attached (use, useSuspense, invalidate, etc.)
  *
- * @param endpoint - The navios endpoint to create query options for
+ * Uses const generics pattern to automatically infer types from the endpoint configuration.
+ *
+ * @param endpoint - The navios endpoint handler (from builder's declareEndpoint)
  * @param options - Query configuration including processResponse
  * @param baseQuery - Optional base query options to merge
  * @returns A function that generates query options with attached helpers
+ *
+ * @example
+ * ```ts
+ * const getUser = api.declareEndpoint({
+ *   method: 'GET',
+ *   url: '/users/$userId',
+ *   responseSchema: userSchema,
+ * })
+ *
+ * const queryOptions = makeQueryOptions(getUser, {
+ *   processResponse: (data) => data,
+ * })
+ *
+ * const { data } = queryOptions.useSuspense({ urlParams: { userId: '123' } })
+ * ```
  */
-declare function makeQueryOptions<Config extends AnyEndpointConfig, Options extends QueryParams<Config>, BaseQuery extends Omit<UseQueryOptions<ReturnType<Options['processResponse']>, Error, any>, 'queryKey' | 'queryFn' | 'getNextPageParam' | 'initialPageParam' | 'enabled' | 'throwOnError' | 'placeholderData'>>(endpoint: AbstractEndpoint<Config>, options: Options, baseQuery?: BaseQuery): {
-  (params: QueryArgs<Config["url"], Config["querySchema"]>): Options["processResponse"] extends ((...args: any[]) => infer Result) ? UseSuspenseQueryOptions<Result, Error, BaseQuery["select"] extends ((...args: any[]) => infer T) ? T : Result, DataTag<Split<Config["url"], "/">, Result, Error>> : never;
-  queryKey: QueryKeyCreatorResult<Config["querySchema"], Config["url"], Options["processResponse"] extends ((...args: any[]) => infer Result) ? Result : never, false, _navios_builder0.UrlHasParams<Config["url"]>>;
-  use(params: QueryArgs<Config["url"], Config["querySchema"]>): _tanstack_react_query1.UseQueryResult<_tanstack_react_query1.NoInfer<BaseQuery["select"] extends ((...args: any[]) => infer T) ? T : unknown>, Error>;
-  useSuspense(params: QueryArgs<Config["url"], Config["querySchema"]>): _tanstack_react_query1.UseSuspenseQueryResult<BaseQuery["select"] extends ((...args: any[]) => infer T) ? T : unknown, Error>;
-  invalidate(queryClient: QueryClient, params: QueryArgs<Config["url"], Config["querySchema"]>): Promise<void>;
-  invalidateAll(queryClient: QueryClient, params: QueryArgs<Config["url"], Config["querySchema"]>): Promise<void>;
-};
+declare function makeQueryOptions<const Options extends EndpointOptions, UseDiscriminator extends boolean = false, Result$1 = QueryResult<Options, UseDiscriminator>, BaseQuery extends Omit<UseQueryOptions<Result$1, Error, any>, 'queryKey' | 'queryFn' | 'getNextPageParam' | 'initialPageParam' | 'enabled' | 'throwOnError' | 'placeholderData'> = Omit<UseQueryOptions<Result$1, Error, any>, 'queryKey' | 'queryFn' | 'getNextPageParam' | 'initialPageParam' | 'enabled' | 'throwOnError' | 'placeholderData'>>(endpoint: EndpointHandler<Options, UseDiscriminator>, options: MakeQueryOptionsParams<Options, UseDiscriminator, Result$1>, baseQuery?: BaseQuery): ((params: Simplify<QueryArgs<Options['url'], Options extends {
+  querySchema: infer Q extends ZodObject;
+} ? Q : undefined, Options extends {
+  requestSchema: infer R extends ZodType;
+} ? R : undefined>>) => UseSuspenseQueryOptions<Result$1, Error, BaseQuery extends {
+  select: (...args: any[]) => infer T;
+} ? T : Result$1, DataTag<Split<Options['url'], '/'>, Result$1, Error>>) & QueryHelpers<Options['url'], Options extends {
+  querySchema: infer Q extends ZodObject;
+} ? Q : undefined, Result$1, false, Options extends {
+  requestSchema: infer R extends ZodType;
+} ? R : undefined>;
 //#endregion
 //#region src/query/make-infinite-options.d.mts
 /**
@@ -156,52 +228,317 @@ declare function makeQueryOptions<Config extends AnyEndpointConfig, Options exte
  */
 declare function makeInfiniteQueryOptions<Config extends AnyEndpointConfig, Options extends InfiniteQueryOptions<Config>, BaseQuery extends Omit<UseInfiniteQueryOptions<ReturnType<Options['processResponse']>, Error, any>, 'queryKey' | 'queryFn' | 'getNextPageParam' | 'initialPageParam' | 'placeholderData' | 'throwOnError'>>(endpoint: AbstractEndpoint<Config>, options: Options, baseQuery?: BaseQuery): {
   (params: QueryArgs<Config["url"], Config["querySchema"]>): Options["processResponse"] extends ((...args: any[]) => infer Result) ? UseSuspenseInfiniteQueryOptions<Result, Error, BaseQuery["select"] extends ((...args: any[]) => infer T) ? T : InfiniteData<Result>> : never;
+  /** The query key creator for this infinite query endpoint */
   queryKey: QueryKeyCreatorResult<Config["querySchema"], Config["url"], Options["processResponse"] extends ((...args: any[]) => infer Result) ? Result : never, true, _navios_builder0.UrlHasParams<Config["url"]>>;
-  use(params: QueryArgs<Config["url"], Config["querySchema"]>): _tanstack_react_query1.UseInfiniteQueryResult<BaseQuery["select"] extends ((...args: any[]) => infer T) ? T : InfiniteData<unknown, unknown>, Error>;
-  useSuspense(params: QueryArgs<Config["url"], Config["querySchema"]>): _tanstack_react_query1.UseSuspenseInfiniteQueryResult<BaseQuery["select"] extends ((...args: any[]) => infer T) ? T : InfiniteData<unknown, unknown>, Error>;
-  invalidate(queryClient: QueryClient, params: QueryArgs<Config["url"], Config["querySchema"]>): Promise<void>;
-  invalidateAll(queryClient: QueryClient, params: QueryArgs<Config["url"], Config["querySchema"]>): Promise<void>;
+  use(params: QueryArgs<Config["url"], Config["querySchema"]>): _tanstack_react_query0.UseInfiniteQueryResult<BaseQuery["select"] extends ((...args: any[]) => infer T) ? T : InfiniteData<unknown, unknown>, Error>;
+  useSuspense(params: QueryArgs<Config["url"], Config["querySchema"]>): _tanstack_react_query0.UseSuspenseInfiniteQueryResult<BaseQuery["select"] extends ((...args: any[]) => infer T) ? T : InfiniteData<unknown, unknown>, Error>;
+  invalidate(queryClient: QueryClient, params: QueryArgs<Config["url"], Config["querySchema"]>): () => Promise<void>;
+  invalidateAll(queryClient: QueryClient, params: QueryArgs<Config["url"], Config["querySchema"]>): () => Promise<void>;
 };
 //#endregion
+//#region src/query/prefetch.d.mts
+/**
+ * Type for a query options creator function that returns TanStack Query options.
+ *
+ * This matches the return type of `client.query()` from the navios react-query client.
+ */
+type QueryOptionsCreator<TParams$1, TData$1, TError$1 = Error> = (params: TParams$1) => FetchQueryOptions<TData$1, TError$1, TData$1, QueryKey>;
+/**
+ * Helper utilities for prefetching queries.
+ *
+ * @template TParams - The query parameters type
+ * @template TData - The query data type
+ * @template TError - The error type (defaults to Error)
+ */
+interface PrefetchHelper<TParams$1, TData$1, TError$1 = Error> {
+  /**
+   * Prefetch query data on the server.
+   *
+   * Use this in server components or getServerSideProps to
+   * prefetch data before rendering.
+   *
+   * @param queryClient - The QueryClient instance
+   * @param params - Parameters for the query
+   * @returns Promise that resolves when prefetch is complete
+   *
+   * @example
+   * ```tsx
+   * // In a Next.js Server Component
+   * const queryClient = new QueryClient()
+   * await prefetch.prefetch(queryClient, { urlParams: { userId: '1' } })
+   * return (
+   *   <HydrationBoundary state={dehydrate(queryClient)}>
+   *     <UserProfile userId="1" />
+   *   </HydrationBoundary>
+   * )
+   * ```
+   */
+  prefetch: (queryClient: QueryClient, params: TParams$1) => Promise<void>;
+  /**
+   * Ensure query data exists in cache. Fetches only if not cached.
+   *
+   * Returns the cached or fetched data.
+   *
+   * @param queryClient - The QueryClient instance
+   * @param params - Parameters for the query
+   * @returns Promise that resolves to the query data
+   *
+   * @example
+   * ```tsx
+   * // Ensure data exists before rendering
+   * const userData = await prefetch.ensureData(queryClient, {
+   *   urlParams: { userId: '1' },
+   * })
+   * console.log('User:', userData.name)
+   * ```
+   */
+  ensureData: (queryClient: QueryClient, params: TParams$1) => Promise<TData$1>;
+  /**
+   * Get the query options for a given set of parameters.
+   *
+   * Useful for advanced use cases or when you need to
+   * customize the prefetch behavior.
+   *
+   * @param params - Parameters for the query
+   * @returns The query options object
+   *
+   * @example
+   * ```tsx
+   * const options = prefetch.getQueryOptions({ urlParams: { userId: '1' } })
+   * await queryClient.prefetchQuery({
+   *   ...options,
+   *   staleTime: 60000, // Override stale time for prefetch
+   * })
+   * ```
+   */
+  getQueryOptions: (params: TParams$1) => FetchQueryOptions<TData$1, TError$1, TData$1, QueryKey>;
+  /**
+   * Prefetch multiple queries in parallel.
+   *
+   * @param queryClient - The QueryClient instance
+   * @param paramsList - Array of parameters for multiple queries
+   * @returns Promise that resolves when all prefetches complete
+   *
+   * @example
+   * ```tsx
+   * // Prefetch multiple users in parallel
+   * await prefetch.prefetchMany(queryClient, [
+   *   { urlParams: { userId: '1' } },
+   *   { urlParams: { userId: '2' } },
+   *   { urlParams: { userId: '3' } },
+   * ])
+   * ```
+   */
+  prefetchMany: (queryClient: QueryClient, paramsList: TParams$1[]) => Promise<void>;
+}
+/**
+ * Creates a type-safe prefetch helper for SSR/RSC.
+ *
+ * This utility wraps a query options creator to provide convenient
+ * methods for server-side data fetching and hydration.
+ *
+ * @param queryOptionsCreator - A function that creates query options (from client.query())
+ * @returns A prefetch helper object with prefetch, ensureData, and getQueryOptions methods
+ *
+ * @example
+ * ```tsx
+ * // 1. Create your query
+ * const getUserQuery = client.query({
+ *   method: 'GET',
+ *   url: '/users/$userId',
+ *   responseSchema: userSchema,
+ * })
+ *
+ * // 2. Create prefetch helper
+ * const userPrefetch = createPrefetchHelper(getUserQuery)
+ *
+ * // 3. Use in server component
+ * async function UserPage({ userId }: { userId: string }) {
+ *   const queryClient = new QueryClient()
+ *
+ *   await userPrefetch.prefetch(queryClient, {
+ *     urlParams: { userId },
+ *   })
+ *
+ *   return (
+ *     <HydrationBoundary state={dehydrate(queryClient)}>
+ *       <UserProfile userId={userId} />
+ *     </HydrationBoundary>
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With Next.js App Router
+ * import { dehydrate, HydrationBoundary, QueryClient } from '@tanstack/react-query'
+ * import { createPrefetchHelper } from '@navios/react-query'
+ *
+ * // Define queries
+ * const getPostsQuery = client.query({
+ *   method: 'GET',
+ *   url: '/posts',
+ *   querySchema: z.object({ page: z.number() }),
+ *   responseSchema: postsSchema,
+ * })
+ *
+ * const postsPrefetch = createPrefetchHelper(getPostsQuery)
+ *
+ * // Server Component
+ * export default async function PostsPage() {
+ *   const queryClient = new QueryClient()
+ *
+ *   await postsPrefetch.prefetch(queryClient, {
+ *     params: { page: 1 },
+ *   })
+ *
+ *   return (
+ *     <HydrationBoundary state={dehydrate(queryClient)}>
+ *       <PostsList />
+ *     </HydrationBoundary>
+ *   )
+ * }
+ * ```
+ */
+declare function createPrefetchHelper<TParams$1, TData$1, TError$1 = Error>(queryOptionsCreator: QueryOptionsCreator<TParams$1, TData$1, TError$1>): PrefetchHelper<TParams$1, TData$1, TError$1>;
+/**
+ * Creates multiple prefetch helpers from a record of query options creators.
+ *
+ * Useful when you have multiple queries that need to be prefetched together.
+ *
+ * @param queries - Record of query options creator functions
+ * @returns Record of prefetch helpers with the same keys
+ *
+ * @example
+ * ```tsx
+ * // Define all your queries
+ * const queries = {
+ *   user: client.query({
+ *     method: 'GET',
+ *     url: '/users/$userId',
+ *     responseSchema: userSchema,
+ *   }),
+ *   posts: client.query({
+ *     method: 'GET',
+ *     url: '/users/$userId/posts',
+ *     responseSchema: postsSchema,
+ *   }),
+ * }
+ *
+ * // Create all prefetch helpers at once
+ * const prefetchers = createPrefetchHelpers(queries)
+ *
+ * // Use in server component
+ * async function UserPage({ userId }: { userId: string }) {
+ *   const queryClient = new QueryClient()
+ *
+ *   await Promise.all([
+ *     prefetchers.user.prefetch(queryClient, { urlParams: { userId } }),
+ *     prefetchers.posts.prefetch(queryClient, { urlParams: { userId } }),
+ *   ])
+ *
+ *   return (
+ *     <HydrationBoundary state={dehydrate(queryClient)}>
+ *       <UserProfileWithPosts userId={userId} />
+ *     </HydrationBoundary>
+ *   )
+ * }
+ * ```
+ */
+declare function createPrefetchHelpers<T$1 extends Record<string, QueryOptionsCreator<any, any, any>>>(queries: T$1): { [K in keyof T$1]: T$1[K] extends QueryOptionsCreator<infer TParams, infer TData, infer TError> ? PrefetchHelper<TParams, TData, TError> : never };
+/**
+ * Prefetch multiple queries from different query creators in parallel.
+ *
+ * @param queryClient - The QueryClient instance
+ * @param prefetches - Array of { helper, params } objects
+ * @returns Promise that resolves when all prefetches complete
+ *
+ * @example
+ * ```tsx
+ * const userPrefetch = createPrefetchHelper(getUserQuery)
+ * const postsPrefetch = createPrefetchHelper(getPostsQuery)
+ *
+ * async function DashboardPage({ userId }: { userId: string }) {
+ *   const queryClient = new QueryClient()
+ *
+ *   await prefetchAll(queryClient, [
+ *     { helper: userPrefetch, params: { urlParams: { userId } } },
+ *     { helper: postsPrefetch, params: { urlParams: { userId }, params: { limit: 10 } } },
+ *   ])
+ *
+ *   return (
+ *     <HydrationBoundary state={dehydrate(queryClient)}>
+ *       <Dashboard userId={userId} />
+ *     </HydrationBoundary>
+ *   )
+ * }
+ * ```
+ */
+declare function prefetchAll(queryClient: QueryClient, prefetches: Array<{
+  helper: PrefetchHelper<any, any, any>;
+  params: unknown;
+}>): Promise<void>;
+//#endregion
 //#region src/mutation/types.d.mts
 /**
  * Arguments for mutation functions based on URL params, request schema, and query schema.
+ * Uses RequestArgs from builder for consistency.
  */
-type MutationArgs<Url extends string = string, RequestSchema = unknown, QuerySchema = unknown> = (UrlHasParams<Url> extends true ? {
-  urlParams: UrlParams<Url>;
-} : {}) & (RequestSchema extends ZodObject ? {
-  data: z.input<RequestSchema>;
-} : {}) & (QuerySchema extends ZodObject ? {
-  params: z.input<QuerySchema>;
-} : {});
+type MutationArgs<Url extends string = string, RequestSchema extends ZodType | undefined = undefined, QuerySchema extends ZodObject | undefined = undefined> = RequestArgs<Url, QuerySchema, RequestSchema>;
 /**
  * Helper methods attached to mutation hooks.
+ *
+ * @template Url - The URL template string
+ * @template Result - The mutation result type
  */
 type MutationHelpers<Url extends string, Result$1 = unknown> = UrlHasParams<Url> extends true ? {
-  mutationKey: (params: UrlParams<Url>) => DataTag<[Url], Result$1, Error>;
-  useIsMutating: (keyParams: UrlParams<Url>) => boolean;
+  /**
+   * Generates a mutation key for the given URL parameters.
+   * Useful for tracking mutations or invalidating related queries.
+   */
+  mutationKey: (params: {
+    urlParams: UrlParams<Url>;
+  }) => DataTag<[Url], Result$1, Error>;
+  /**
+   * Returns true if a mutation with the given URL parameters is currently in progress.
+   * Requires `useKey: true` to be set when creating the mutation.
+   */
+  useIsMutating: (keyParams: {
+    urlParams: UrlParams<Url>;
+  }) => boolean;
 } : {
+  /**
+   * Generates a mutation key.
+   * Useful for tracking mutations or invalidating related queries.
+   */
   mutationKey: () => DataTag<[Url], Result$1, Error>;
+  /**
+   * Returns true if a mutation is currently in progress.
+   * Requires `useKey: true` to be set when creating the mutation.
+   */
   useIsMutating: () => boolean;
 };
 /**
  * Base parameters for mutation configuration.
+ *
+ * @template UseDiscriminator - When `true`, errors are returned as union types in processResponse.
+ *   When `false` (default), errors are thrown and not included in TResponse.
  */
-interface MutationParams<Config extends AnyEndpointConfig, TData = unknown, TVariables = NaviosZodRequest<Config>, TResponse = z.output<Config['responseSchema']>, TOnMutateResult = unknown, TContext = unknown, UseKey extends boolean = false> extends Omit<UseMutationOptions<TData, Error, TVariables>, 'mutationKey' | 'mutationFn' | 'onMutate' | 'onSuccess' | 'onError' | 'onSettled' | 'scope'> {
-  processResponse?: ProcessResponseFunction<TData, TResponse>;
+interface MutationParams<Config extends AnyEndpointConfig, TData$1 = unknown, TVariables = RequestArgs<Config['url'], Config['querySchema'], Config['requestSchema'], Config['urlParamsSchema']>, _TResponse = ComputeResponseInput<false, Config['responseSchema'], Config['errorSchema']>, TOnMutateResult = unknown, TContext = unknown, UseKey extends boolean = false, UseDiscriminator extends boolean = false, TError$1 = (UseDiscriminator extends true ? Error : Config['errorSchema'] extends ErrorSchemaRecord ? InferErrorSchemaOutput<Config['errorSchema']> | Error : Error)> extends Omit<UseMutationOptions<TData$1, TError$1, TVariables>, 'mutationKey' | 'mutationFn' | 'onMutate' | 'onSuccess' | 'onError' | 'onSettled' | 'scope'> {
+  processResponse?: ProcessResponseFunction<TData$1, ComputeResponseInput<UseDiscriminator, Config['responseSchema'], Config['errorSchema']>>;
   /**
    * React hooks that will prepare the context for the mutation onSuccess and onError
    * callbacks. This is useful for when you want to use the context in the callbacks
    */
   useContext?: () => TContext;
-  onSuccess?: (data: TData, variables: TVariables, context: TContext & MutationFunctionContext & {
+  onSuccess?: (data: TData$1, variables: TVariables, context: TContext & MutationFunctionContext & {
     onMutateResult: TOnMutateResult | undefined;
   }) => void | Promise<void>;
-  onError?: (err: unknown, variables: TVariables, context: TContext & MutationFunctionContext & {
+  onError?: (err: TError$1, variables: TVariables, context: TContext & MutationFunctionContext & {
     onMutateResult: TOnMutateResult | undefined;
   }) => void | Promise<void>;
   onMutate?: (variables: TVariables, context: TContext & MutationFunctionContext) => TOnMutateResult | Promise<TOnMutateResult>;
-  onSettled?: (data: TData | undefined, error: Error | null, variables: TVariables, context: TContext & MutationFunctionContext & {
+  onSettled?: (data: TData$1 | undefined, error: TError$1 | null, variables: TVariables, context: TContext & MutationFunctionContext & {
     onMutateResult: TOnMutateResult | undefined;
   }) => void | Promise<void>;
   /**
@@ -212,11 +549,11 @@ interface MutationParams<Config extends AnyEndpointConfig, TData = unknown, TVar
   keySuffix?: UseKey extends true ? UrlHasParams<Config['url']> extends true ? string[] : never : never;
 }
 /** @deprecated Use MutationArgs instead */
-type ClientMutationArgs<Url extends string = string, RequestSchema = unknown, QuerySchema = unknown> = MutationArgs<Url, RequestSchema, QuerySchema>;
+type ClientMutationArgs<Url extends string = string, RequestSchema extends ZodType | undefined = undefined, QuerySchema extends ZodObject | undefined = undefined> = MutationArgs<Url, RequestSchema, QuerySchema>;
 /** @deprecated Use MutationParams instead */
-type BaseMutationParams<Config extends AnyEndpointConfig, TData = unknown, TVariables = NaviosZodRequest<Config>, TResponse = z.output<Config['responseSchema']>, TContext = unknown, UseKey extends boolean = false> = MutationParams<Config, TData, TVariables, TResponse, TContext, UseKey>;
-/** @deprecated Use NaviosZodRequest from @navios/builder instead */
-type BaseMutationArgs<Config extends AnyEndpointConfig> = NaviosZodRequest<Config>;
+type BaseMutationParams<Config extends AnyEndpointConfig, TData$1 = unknown, TVariables = RequestArgs<Config['url'], Config['querySchema'], Config['requestSchema'], Config['urlParamsSchema']>, TResponse = z.output<Config['responseSchema']>, TContext = unknown, UseKey extends boolean = false> = MutationParams<Config, TData$1, TVariables, TResponse, TContext, UseKey>;
+/** @deprecated Use RequestArgs from @navios/builder instead */
+type BaseMutationArgs<Config extends AnyEndpointConfig> = RequestArgs<Config['url'], Config['querySchema'], Config['requestSchema'], Config['urlParamsSchema']>;
 //#endregion
 //#region src/mutation/key-creator.d.mts
 /**
@@ -253,6 +590,36 @@ declare function createMutationKey<Config extends AnyEndpointConfig, Options ext
 declare const mutationKeyCreator: typeof createMutationKey;
 //#endregion
 //#region src/mutation/make-hook.d.mts
+/**
+ * Helper type for endpoint with config property
+ */
+type EndpointWithConfig<Config extends AnyEndpointConfig> = ((params: any) => Promise<any>) & {
+  config: Config;
+};
+/**
+ * Helper type for response input when errorSchema is present
+ */
+type ResponseInput<ResponseSchema extends ZodType, ErrorSchema extends ErrorSchemaRecord | undefined> = ErrorSchema extends ErrorSchemaRecord ? z.output<ResponseSchema> | InferErrorSchemaOutput<ErrorSchema> : z.output<ResponseSchema>;
+/**
+ * Options type for makeMutation
+ */
+type MakeMutationParams<Config extends AnyEndpointConfig, ResponseSchema extends ZodType, ErrorSchema extends ErrorSchemaRecord | undefined, TData$1, TVariables, TOnMutateResult, TContext, UseKey extends boolean> = Omit<UseMutationOptions<TData$1, Error, TVariables>, 'mutationKey' | 'mutationFn' | 'onMutate' | 'onSuccess' | 'onError' | 'onSettled' | 'scope'> & {
+  processResponse?: ProcessResponseFunction<TData$1, ResponseInput<ResponseSchema, ErrorSchema>>;
+  useContext?: () => TContext;
+  onSuccess?: (data: TData$1, variables: TVariables, context: TContext & MutationFunctionContext & {
+    onMutateResult: TOnMutateResult | undefined;
+  }) => void | Promise<void>;
+  onError?: (err: unknown, variables: TVariables, context: TContext & MutationFunctionContext & {
+    onMutateResult: TOnMutateResult | undefined;
+  }) => void | Promise<void>;
+  onMutate?: (variables: TVariables, context: TContext & MutationFunctionContext) => TOnMutateResult | Promise<TOnMutateResult>;
+  onSettled?: (data: TData$1 | undefined, error: Error | null, variables: TVariables, context: TContext & MutationFunctionContext & {
+    onMutateResult: TOnMutateResult | undefined;
+  }) => void | Promise<void>;
+  useKey?: UseKey;
+  keyPrefix?: UseKey extends true ? UrlHasParams<Config['url']> extends true ? string[] : never : never;
+  keySuffix?: UseKey extends true ? UrlHasParams<Config['url']> extends true ? string[] : never : never;
+};
 /**
  * Creates a mutation hook for a given endpoint.
  *
@@ -263,645 +630,693 @@ declare const mutationKeyCreator: typeof createMutationKey;
  * @param options - Mutation configuration including processResponse and callbacks
  * @returns A hook function that returns mutation result with attached helpers
  */
-declare function makeMutation<Config extends AnyEndpointConfig, TData = unknown, TVariables extends NaviosZodRequest<Config> = NaviosZodRequest<Config>, TResponse = z.output<Config['responseSchema']>, TOnMutateResult = unknown, TContext = unknown, UseKey extends boolean = false>(endpoint: AbstractEndpoint<Config>, options: MutationParams<Config, TData, TVariables, TResponse, TOnMutateResult, TContext, UseKey>): {
-  (keyParams: UseKey extends true ? UrlHasParams<Config["url"]> extends true ? {
-    urlParams: UrlParams<Config["url"]>;
-  } : never : never): UseMutationResult<TData, Error, NaviosZodRequest<Config>, TOnMutateResult>;
-  useIsMutating(keyParams: UseKey extends true ? UrlHasParams<Config["url"]> extends true ? UrlParams<Config["url"]> : never : never): boolean;
-  mutationKey: (params: UrlHasParams<Config["url"]> extends infer T ? T extends UrlHasParams<Config["url"]> ? T extends true ? {
-    urlParams: UrlParams<Config["url"]>;
-  } : {} : never : never) => ProcessResponseFunction<TData, TResponse> | ((data: z.core.output<Config["responseSchema"]>) => z.core.output<Config["responseSchema"]>) extends ((...args: unknown[]) => infer Result) ? [Config["url"]] & {
-    [dataTagSymbol]: Result;
-    [dataTagErrorSymbol]: Error;
-  } : never;
-};
+declare function makeMutation<Method extends HttpMethod, Url extends string, QuerySchema extends ZodObject | undefined, ResponseSchema extends ZodType, RequestSchema extends ZodType, ErrorSchema extends ErrorSchemaRecord, TData$1, TOnMutateResult = unknown, TContext = unknown, UseKey extends boolean = false>(endpoint: EndpointWithConfig<BaseEndpointConfig<Method, Url, QuerySchema, ResponseSchema, RequestSchema, ErrorSchema>>, options: MakeMutationParams<BaseEndpointConfig<Method, Url, QuerySchema, ResponseSchema, RequestSchema, ErrorSchema>, ResponseSchema, ErrorSchema, TData$1, any, TOnMutateResult, TContext, UseKey>): ((keyParams: UseKey extends true ? UrlHasParams<Url> extends true ? {
+  urlParams: UrlParams<Url>;
+} : never : never) => UseMutationResult<TData$1, Error, any, TOnMutateResult>) & MutationHelpers<Url, TData$1>;
+declare function makeMutation<Method extends HttpMethod, Url extends string, QuerySchema extends ZodObject | undefined, ResponseSchema extends ZodType, RequestSchema extends ZodType | undefined, TData$1, TOnMutateResult = unknown, TContext = unknown, UseKey extends boolean = false>(endpoint: EndpointWithConfig<BaseEndpointConfig<Method, Url, QuerySchema, ResponseSchema, RequestSchema, undefined>>, options: MakeMutationParams<BaseEndpointConfig<Method, Url, QuerySchema, ResponseSchema, RequestSchema, undefined>, ResponseSchema, undefined, TData$1, any, TOnMutateResult, TContext, UseKey>): ((keyParams: UseKey extends true ? UrlHasParams<Url> extends true ? {
+  urlParams: UrlParams<Url>;
+} : never : never) => UseMutationResult<TData$1, Error, any, TOnMutateResult>) & MutationHelpers<Url, TData$1>;
 //#endregion
-//#region src/client/types.d.mts
+//#region src/mutation/optimistic.d.mts
+/**
+ * Configuration for creating optimistic update callbacks.
+ *
+ * @template TData - The mutation response data type
+ * @template TVariables - The mutation variables type
+ * @template TQueryData - The query cache data type
+ */
+interface OptimisticUpdateConfig<_TData, TVariables, TQueryData> {
+  /**
+   * The query key to optimistically update.
+   * This should match the query key used for the affected query.
+   */
+  queryKey: readonly unknown[];
+  /**
+   * Function to compute the optimistic cache value.
+   * Receives the current cache data and mutation variables.
+   *
+   * @param oldData - Current data in the cache (may be undefined if not cached)
+   * @param variables - The mutation variables being submitted
+   * @returns The new optimistic cache value
+   */
+  updateFn: (oldData: TQueryData | undefined, variables: TVariables) => TQueryData;
+  /**
+   * Whether to rollback on error.
+   * Defaults to true.
+   */
+  rollbackOnError?: boolean;
+  /**
+   * Whether to invalidate the query on settlement.
+   * Defaults to true.
+   */
+  invalidateOnSettled?: boolean;
+}
+/**
+ * Return type for optimistic update callbacks.
+ */
+interface OptimisticUpdateCallbacks<TData$1, TVariables, TQueryData> {
+  /**
+   * Called before the mutation starts. Cancels outgoing refetches,
+   * snapshots the current cache value, and applies the optimistic update.
+   */
+  onMutate: (variables: TVariables, context: {
+    queryClient: QueryClient;
+  }) => Promise<{
+    previousData: TQueryData | undefined;
+  }>;
+  /**
+   * Called when the mutation fails. Rolls back the cache to the previous
+   * value if rollbackOnError is enabled.
+   */
+  onError: (err: Error, variables: TVariables, context: {
+    previousData?: TQueryData;
+    queryClient: QueryClient;
+  }) => void;
+  /**
+   * Called when the mutation completes (success or error).
+   * Invalidates the query if invalidateOnSettled is enabled.
+   */
+  onSettled: (data: TData$1 | undefined, error: Error | null, variables: TVariables, context: {
+    queryClient: QueryClient;
+  }) => void;
+}
+/**
+ * Creates type-safe optimistic update callbacks for mutations.
+ *
+ * This helper generates the onMutate, onError, and onSettled callbacks
+ * that implement the standard optimistic update pattern:
+ *
+ * 1. onMutate: Cancel refetches, snapshot cache, apply optimistic update
+ * 2. onError: Rollback cache to previous value on failure
+ * 3. onSettled: Invalidate query to refetch fresh data
+ *
+ * @experimental This API is experimental and may change in future versions.
+ * Use with caution in production code.
+ *
+ * @param config - Configuration for the optimistic update
+ * @returns Object containing onMutate, onError, and onSettled callbacks
+ *
+ * @example
+ * ```ts
+ * // Create a mutation with optimistic updates
+ * const updateUser = client.mutation({
+ *   method: 'PATCH',
+ *   url: '/users/$userId',
+ *   requestSchema: updateUserSchema,
+ *   responseSchema: userSchema,
+ *   processResponse: (data) => data,
+ *   ...createOptimisticUpdate({
+ *     queryKey: ['users', userId],
+ *     updateFn: (oldData, variables) => ({
+ *       ...oldData,
+ *       ...variables.data,
+ *     }),
+ *   }),
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Optimistic update for adding an item to a list
+ * const addTodo = client.mutation({
+ *   method: 'POST',
+ *   url: '/todos',
+ *   requestSchema: createTodoSchema,
+ *   responseSchema: todoSchema,
+ *   processResponse: (data) => data,
+ *   ...createOptimisticUpdate({
+ *     queryKey: ['todos'],
+ *     updateFn: (oldData, variables) => [
+ *       ...(oldData ?? []),
+ *       { id: 'temp-id', ...variables.data, createdAt: new Date() },
+ *     ],
+ *   }),
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Optimistic delete
+ * const deleteTodo = client.mutation({
+ *   method: 'DELETE',
+ *   url: '/todos/$todoId',
+ *   responseSchema: z.object({ success: z.boolean() }),
+ *   processResponse: (data) => data,
+ *   ...createOptimisticUpdate({
+ *     queryKey: ['todos'],
+ *     updateFn: (oldData, variables) =>
+ *       (oldData ?? []).filter((t) => t.id !== variables.urlParams.todoId),
+ *   }),
+ * })
+ * ```
+ */
+declare function createOptimisticUpdate<TData$1, TVariables, TQueryData>(config: OptimisticUpdateConfig<TData$1, TVariables, TQueryData>): OptimisticUpdateCallbacks<TData$1, TVariables, TQueryData>;
+/**
+ * Creates optimistic update callbacks that work with multiple query keys.
+ *
+ * Useful when a mutation affects multiple cached queries.
+ *
+ * @experimental This API is experimental and may change in future versions.
+ * Use with caution in production code.
+ *
+ * @param configs - Array of optimistic update configurations
+ * @returns Combined callbacks that handle all specified queries
+ *
+ * @example
+ * ```ts
+ * // Updating a user affects both user detail and user list queries
+ * const updateUser = client.mutation({
+ *   method: 'PATCH',
+ *   url: '/users/$userId',
+ *   requestSchema: updateUserSchema,
+ *   responseSchema: userSchema,
+ *   processResponse: (data) => data,
+ *   ...createMultiOptimisticUpdate([
+ *     {
+ *       queryKey: ['users', userId],
+ *       updateFn: (oldData, variables) => ({ ...oldData, ...variables.data }),
+ *     },
+ *     {
+ *       queryKey: ['users'],
+ *       updateFn: (oldList, variables) =>
+ *         (oldList ?? []).map((u) =>
+ *           u.id === userId ? { ...u, ...variables.data } : u
+ *         ),
+ *     },
+ *   ]),
+ * })
+ * ```
+ */
+declare function createMultiOptimisticUpdate<TData$1, TVariables>(configs: Array<OptimisticUpdateConfig<TData$1, TVariables, unknown>>): OptimisticUpdateCallbacks<TData$1, TVariables, Map<string, unknown>>;
+//#endregion
+//#region src/client/types/helpers.d.mts
+/**
+ * Compute the base result type based on discriminator and error schema.
+ * When UseDiscriminator=true and errorSchema is present, errors are included as a union.
+ * When UseDiscriminator=false, only the success type is returned (errors are thrown).
+ */
+type ComputeBaseResult<UseDiscriminator extends boolean, ResponseSchema extends ZodType, ErrorSchema extends ErrorSchemaRecord | undefined> = UseDiscriminator extends true ? ErrorSchema extends ErrorSchemaRecord ? z.output<ResponseSchema> | InferErrorSchemaOutput<ErrorSchema> : z.output<ResponseSchema> : z.output<ResponseSchema>;
+/**
+ * Helper type to compute the response data type based on errorSchema presence and UseDiscriminator.
+ *
+ * When `UseDiscriminator` is `true` and `errorSchema` exists, returns `ResponseType | ErrorTypes`.
+ * When `UseDiscriminator` is `false`, returns only `ResponseType` (errors are thrown).
+ *
+ * @deprecated Use ComputeBaseResult instead (same logic, different parameter order)
+ */
+type ResponseDataType<Response extends ZodType, ErrorSchema extends ErrorSchemaRecord | undefined, UseDiscriminator extends boolean = false> = ComputeBaseResult<UseDiscriminator, Response, ErrorSchema>;
 /**
  * Helper type that attaches the endpoint to query/mutation results.
+ * Supports both new const generic pattern and legacy pattern with individual parameters.
+ *
+ * New pattern (2 args):
+ * @template Options - EndpointOptions from builder (new const generic pattern)
+ * @template UseDiscriminator - When true, errors are returned as union types
+ *
+ * Legacy pattern (4-5 args):
+ * @template Method - HTTP method
+ * @template Url - URL template
+ * @template RequestSchema - Request body schema
+ * @template ResponseSchema - Response schema
+ * @template QuerySchema - Query params schema (optional)
  */
-type EndpointHelper<Method extends HttpMethod = HttpMethod, Url extends string = string, RequestSchema = unknown, ResponseSchema extends z.ZodType = z.ZodType, QuerySchema = unknown> = {
-  endpoint: ((params: Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, RequestSchema>>) => Promise<z.output<ResponseSchema>>) & {
-    config: BaseEndpointConfig<Method, Url, QuerySchema, ResponseSchema, RequestSchema>;
-  };
-};
+type EndpointHelper<OptionsOrMethod extends EndpointOptions | HttpMethod = EndpointOptions, UseDiscriminatorOrUrl extends boolean | string = false, RequestSchema = undefined, ResponseSchema extends ZodType = ZodType, QuerySchema = undefined> = OptionsOrMethod extends EndpointOptions ? UseDiscriminatorOrUrl extends boolean ? {
+  endpoint: EndpointHandler<OptionsOrMethod, UseDiscriminatorOrUrl>;
+} : never : OptionsOrMethod extends HttpMethod ? UseDiscriminatorOrUrl extends string ? {
+  endpoint: EndpointHandler<EndpointOptions & {
+    method: OptionsOrMethod;
+    url: UseDiscriminatorOrUrl;
+    requestSchema: RequestSchema;
+    responseSchema: ResponseSchema;
+    querySchema: QuerySchema;
+  }, false>;
+} : never : never;
 /** @deprecated Use EndpointHelper instead */
 type ClientEndpointHelper<Method extends HttpMethod = HttpMethod, Url extends string = string, RequestSchema = unknown, ResponseSchema extends z.ZodType = z.ZodType, QuerySchema = unknown> = EndpointHelper<Method, Url, RequestSchema, ResponseSchema, QuerySchema>;
 /**
  * Helper type that attaches a stream endpoint to mutation results.
+ * Supports both new const generic pattern and legacy pattern with individual parameters.
+ *
+ * New pattern (2 args):
+ * @template Options - BaseEndpointOptions from builder (new const generic pattern)
+ * @template UseDiscriminator - When true, errors are returned as union types
+ *
+ * Legacy pattern (4-6 args):
+ * @template Method - HTTP method
+ * @template Url - URL template
+ * @template QuerySchema - Query params schema
+ * @template RequestSchema - Request body schema
+ * @template ErrorSchema - Error schema (optional)
+ * @template UrlParamsSchema - URL params schema (optional)
  */
-type StreamHelper<Method extends HttpMethod = HttpMethod, Url extends string = string, RequestSchema = unknown, QuerySchema = unknown> = {
-  endpoint: ((params: Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, RequestSchema>>) => Promise<Blob>) & {
-    config: BaseStreamConfig<Method, Url, QuerySchema, RequestSchema>;
-  };
-};
+type StreamHelper<OptionsOrMethod extends BaseEndpointOptions | HttpMethod = BaseEndpointOptions, UseDiscriminatorOrUrl extends boolean | string = false, QuerySchema = undefined, RequestSchema = undefined, ErrorSchema = undefined, UrlParamsSchema = undefined> = OptionsOrMethod extends BaseEndpointOptions ? UseDiscriminatorOrUrl extends boolean ? {
+  endpoint: StreamHandler<OptionsOrMethod, UseDiscriminatorOrUrl>;
+} : never : OptionsOrMethod extends HttpMethod ? UseDiscriminatorOrUrl extends string ? {
+  endpoint: StreamHandler<BaseEndpointOptions & {
+    method: OptionsOrMethod;
+    url: UseDiscriminatorOrUrl;
+    querySchema: QuerySchema;
+    requestSchema: RequestSchema;
+    errorSchema: ErrorSchema;
+    urlParamsSchema: UrlParamsSchema;
+  }, false>;
+} : never : never;
+//#endregion
+//#region src/client/types/query.d.mts
 /**
- * The main client instance interface.
- * Provides methods for creating queries, infinite queries, and mutations.
+ * Helper type to build endpoint options without including undefined properties.
+ * This ensures HasProperty correctly identifies missing properties.
  */
-interface ClientInstance {
-  query<Method extends 'GET' | 'HEAD' | 'OPTIONS' = 'GET', Url extends string = string, Response extends ZodType = ZodType, Result$1 = z.output<Response>>(config: {
-    method: Method;
-    url: Url;
-    responseSchema: Response;
-    processResponse?: (data: z.output<Response>) => Result$1;
-  }): ((params: Util_FlatObject<QueryArgs<Url, undefined>>) => UseSuspenseQueryOptions<Result$1, Error, Result$1, DataTag<Split<Url, '/'>, Result$1, Error>>) & QueryHelpers<Url, undefined, Result$1> & EndpointHelper<Method, Url, undefined, Response>;
-  query<Method extends 'GET' | 'HEAD' | 'OPTIONS' = 'GET', Url extends string = string, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, Result$1 = z.output<Response>>(config: {
+type BuildEndpointOptions<Method extends HttpMethod, Url extends string, QuerySchema extends ZodObject | undefined, RequestSchema extends ZodType | undefined, ResponseSchema extends ZodType, ErrorSchema extends ErrorSchemaRecord | undefined, UrlParamsSchema extends ZodObject | undefined> = {
+  method: Method;
+  url: Url;
+  responseSchema: ResponseSchema;
+} & (QuerySchema extends undefined ? {} : {
+  querySchema: QuerySchema;
+}) & (RequestSchema extends undefined ? {} : {
+  requestSchema: RequestSchema;
+}) & (ErrorSchema extends undefined ? {} : {
+  errorSchema: ErrorSchema;
+}) & (UrlParamsSchema extends undefined ? {} : {
+  urlParamsSchema: UrlParamsSchema;
+});
+/**
+ * Extended endpoint options interface for query that includes processResponse.
+ */
+interface QueryEndpointConfig<Method extends HttpMethod, Url extends string, QuerySchema extends ZodObject | undefined, RequestSchema extends ZodType | undefined, ResponseSchema extends ZodType, ErrorSchema extends ErrorSchemaRecord | undefined, UrlParamsSchema extends ZodObject | undefined, TBaseResult, Result$1> extends EndpointOptions {
+  method: Method;
+  url: Url;
+  querySchema?: QuerySchema;
+  requestSchema?: RequestSchema;
+  responseSchema: ResponseSchema;
+  errorSchema?: ErrorSchema;
+  urlParamsSchema?: UrlParamsSchema;
+  processResponse?: (data: TBaseResult) => Result$1;
+}
+/**
+ * Query method using decomposed generics pattern for proper processResponse typing.
+ *
+ * @template UseDiscriminator - When `true`, errors are returned as union types.
+ *   When `false` (default), errors are thrown and not included in TData.
+ */
+interface ClientQueryMethods<UseDiscriminator extends boolean = false> {
+  /**
+   * Creates a type-safe query with automatic type inference.
+   *
+   * Uses decomposed generic pattern to infer types from the configuration object.
+   * All schema combinations are handled by a single method.
+   *
+   * @example
+   * ```ts
+   * const getUser = client.query({
+   *   method: 'GET',
+   *   url: '/users/$userId',
+   *   responseSchema: userSchema,
+   *   urlParamsSchema: z.object({ userId: z.string().uuid() }),
+   * })
+   *
+   * const { data } = getUser.useSuspense({ urlParams: { userId: '123' } })
+   * ```
+   */
+  query<const Method extends HttpMethod = HttpMethod, const Url extends string = string, const QuerySchema extends ZodObject | undefined = undefined, const RequestSchema extends ZodType | undefined = undefined, const ResponseSchema extends ZodType = ZodType, const ErrorSchema extends ErrorSchemaRecord | undefined = undefined, const UrlParamsSchema extends ZodObject | undefined = undefined, const TBaseResult = ComputeBaseResult<UseDiscriminator, ResponseSchema, ErrorSchema>, const Result$1 = TBaseResult, const Options extends EndpointOptions = BuildEndpointOptions<Method, Url, QuerySchema, RequestSchema, ResponseSchema, ErrorSchema, UrlParamsSchema>>(config: QueryEndpointConfig<Method, Url, QuerySchema, RequestSchema, ResponseSchema, ErrorSchema, UrlParamsSchema, TBaseResult, Result$1>): ((params: Simplify<InferEndpointParams<Options>>) => UseSuspenseQueryOptions<Result$1, Error, Result$1, DataTag<Split<Url, '/'>, Result$1, Error>>) & QueryHelpers<Url, QuerySchema, Result$1, false, RequestSchema> & EndpointHelper<Options, UseDiscriminator>;
+}
+//#endregion
+//#region src/client/types/infinite-query.d.mts
+/**
+ * Extended endpoint options interface for infinite query that includes processResponse and pagination.
+ */
+interface InfiniteQueryEndpointConfig<_UseDiscriminator extends boolean, Method extends HttpMethod, Url extends string, QuerySchema extends ZodObject, RequestSchema extends ZodType | undefined, ResponseSchema extends ZodType, ErrorSchema extends ErrorSchemaRecord | undefined, UrlParamsSchema extends ZodObject | undefined, TBaseResult, PageResult> extends EndpointOptions {
+  method: Method;
+  url: Url;
+  querySchema: QuerySchema;
+  requestSchema?: RequestSchema;
+  responseSchema: ResponseSchema;
+  errorSchema?: ErrorSchema;
+  urlParamsSchema?: UrlParamsSchema;
+  processResponse?: (data: TBaseResult) => PageResult;
+  getNextPageParam: (lastPage: PageResult, allPages: PageResult[], lastPageParam: z.infer<QuerySchema> | undefined, allPageParams: z.infer<QuerySchema>[] | undefined) => z.input<QuerySchema> | undefined;
+  getPreviousPageParam?: (firstPage: PageResult, allPages: PageResult[], lastPageParam: z.infer<QuerySchema> | undefined, allPageParams: z.infer<QuerySchema>[] | undefined) => z.input<QuerySchema>;
+}
+/**
+ * Infinite query method using decomposed generics pattern for proper processResponse typing.
+ *
+ * @template UseDiscriminator - When `true`, errors are returned as union types.
+ *   When `false` (default), errors are thrown and not included in TData.
+ */
+interface ClientInfiniteQueryMethods<UseDiscriminator extends boolean = false> {
+  /**
+   * Creates a type-safe infinite query with automatic type inference.
+   *
+   * Uses decomposed generic pattern to infer types from the configuration object.
+   * All schema combinations are handled by a single method.
+   *
+   * @example
+   * ```ts
+   * const getUsers = client.infiniteQuery({
+   *   method: 'GET',
+   *   url: '/users',
+   *   querySchema: z.object({ page: z.number() }),
+   *   responseSchema: z.array(userSchema),
+   *   getNextPageParam: (lastPage, allPages, lastPageParam) => {
+   *     return lastPage.length > 0 ? { page: (lastPageParam?.page ?? 0) + 1 } : undefined
+   *   },
+   * })
+   *
+   * const { data } = getUsers.useSuspense({ params: { page: 0 } })
+   * ```
+   */
+  infiniteQuery<const Method extends HttpMethod = HttpMethod, const Url extends string = string, const QuerySchema extends ZodObject = ZodObject, const RequestSchema extends ZodType | undefined = undefined, const ResponseSchema extends ZodType = ZodType, const ErrorSchema extends ErrorSchemaRecord | undefined = undefined, const UrlParamsSchema extends ZodObject | undefined = undefined, const TBaseResult = ComputeBaseResult<UseDiscriminator, ResponseSchema, ErrorSchema>, const PageResult = TBaseResult, const Options extends EndpointOptions = {
     method: Method;
     url: Url;
     querySchema: QuerySchema;
-    responseSchema: Response;
-    processResponse?: (data: z.output<Response>) => Result$1;
-  }): ((params: Util_FlatObject<QueryArgs<Url, QuerySchema>>) => UseSuspenseQueryOptions<Result$1, Error, Result$1, DataTag<Split<Url, '/'>, Result$1, Error>>) & QueryHelpers<Url, QuerySchema, Result$1> & EndpointHelper<Method, Url, undefined, Response, QuerySchema>;
-  query<Method extends 'POST' = 'POST', Url extends string = string, RequestSchema extends ZodType = ZodType, Response extends ZodType = ZodType, Result$1 = z.output<Response>>(config: {
+    requestSchema: RequestSchema;
+    responseSchema: ResponseSchema;
+    errorSchema: ErrorSchema;
+    urlParamsSchema: UrlParamsSchema;
+  }>(config: InfiniteQueryEndpointConfig<UseDiscriminator, Method, Url, QuerySchema, RequestSchema, ResponseSchema, ErrorSchema, UrlParamsSchema, TBaseResult, PageResult>): ((params: Simplify<InferEndpointParams<Options>>) => UseSuspenseInfiniteQueryOptions<PageResult, Error, InfiniteData<PageResult>, DataTag<Split<Url, '/'>, PageResult, Error>, z.output<QuerySchema>>) & QueryHelpers<Url, QuerySchema, PageResult, true, RequestSchema> & EndpointHelper<Options, UseDiscriminator>;
+}
+//#endregion
+//#region src/client/types/mutation.d.mts
+/**
+ * Compute variables type from URL, schemas
+ */
+type ComputeVariables<Url extends string, QuerySchema extends ZodObject | undefined, RequestSchema extends ZodType | undefined, UrlParamsSchema extends ZodObject | undefined> = Simplify<RequestArgs<Url, QuerySchema, RequestSchema, UrlParamsSchema>>;
+/**
+ * Extended endpoint options interface for mutation that includes processResponse and callbacks.
+ */
+interface MutationEndpointConfig<_UseDiscriminator extends boolean, Method extends HttpMethod, Url extends string, QuerySchema extends ZodObject | undefined, RequestSchema extends ZodType | undefined, ResponseSchema extends ZodType, ErrorSchema extends ErrorSchemaRecord | undefined, UrlParamsSchema extends ZodObject | undefined, UseKey extends boolean, TBaseResult, Result$1, OnMutateResult, Context, Variables> extends EndpointOptions {
+  method: Method;
+  url: Url;
+  querySchema?: QuerySchema;
+  requestSchema?: RequestSchema;
+  responseSchema: ResponseSchema;
+  errorSchema?: ErrorSchema;
+  urlParamsSchema?: UrlParamsSchema;
+  processResponse?: (data: TBaseResult) => Result$1 | Promise<Result$1>;
+  useContext?: () => Context;
+  useKey?: UseKey;
+  onMutate?: (variables: Variables, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
+  onSuccess?: (data: NoInfer<Result$1>, variables: Variables, context: Context & MutationFunctionContext & {
+    onMutateResult: OnMutateResult | undefined;
+  }) => void | Promise<void>;
+  onError?: (error: Error, variables: Variables, context: Context & MutationFunctionContext & {
+    onMutateResult: OnMutateResult | undefined;
+  }) => void | Promise<void>;
+  onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Variables, context: Context & MutationFunctionContext & {
+    onMutateResult: OnMutateResult | undefined;
+  }) => void | Promise<void>;
+}
+/**
+ * Mutation method using decomposed generics pattern for proper processResponse typing.
+ *
+ * @template UseDiscriminator - When `true`, errors are returned as union types.
+ *   When `false` (default), errors are thrown and not included in TData.
+ */
+interface ClientMutationMethods<UseDiscriminator extends boolean = false> {
+  /**
+   * Creates a type-safe mutation with automatic type inference.
+   *
+   * Uses decomposed generic pattern to infer types from the configuration object.
+   * All schema combinations are handled by a single method.
+   *
+   * @example
+   * ```ts
+   * const createUser = client.mutation({
+   *   method: 'POST',
+   *   url: '/users',
+   *   requestSchema: createUserSchema,
+   *   responseSchema: userSchema,
+   *   processResponse: (data) => data,
+   * })
+   *
+   * const { mutate } = createUser()
+   * mutate({ data: { name: 'John' } })
+   * ```
+   */
+  mutation<const Method extends HttpMethod = HttpMethod, const Url extends string = string, const QuerySchema extends ZodObject | undefined = undefined, const RequestSchema extends ZodType | undefined = undefined, const ResponseSchema extends ZodType = ZodType, const ErrorSchema extends ErrorSchemaRecord | undefined = undefined, const UrlParamsSchema extends ZodObject | undefined = undefined, const UseKey extends boolean = false, const TBaseResult = ComputeBaseResult<UseDiscriminator, ResponseSchema, ErrorSchema>, const Result$1 = TBaseResult, const OnMutateResult = unknown, const Context = unknown, const Variables = ComputeVariables<Url, QuerySchema, RequestSchema, UrlParamsSchema>, const Options extends EndpointOptions = {
     method: Method;
     url: Url;
+    querySchema: QuerySchema;
     requestSchema: RequestSchema;
-    responseSchema: Response;
-    processResponse?: (data: z.output<Response>) => Result$1;
-  }): ((params: Util_FlatObject<QueryArgs<Url, undefined, RequestSchema>>) => UseSuspenseQueryOptions<Result$1, Error, Result$1, DataTag<Split<Url, '/'>, Result$1, Error>>) & QueryHelpers<Url, undefined, Result$1, false, RequestSchema> & EndpointHelper<Method, Url, RequestSchema, Response>;
-  query<Method extends 'POST' = 'POST', Url extends string = string, QuerySchema extends ZodObject = ZodObject, RequestSchema extends ZodType = ZodType, Response extends ZodType = ZodType, Result$1 = z.output<Response>>(config: {
-    method: Method;
-    url: Url;
-    querySchema: QuerySchema;
-    requestSchema: RequestSchema;
-    responseSchema: Response;
-    processResponse?: (data: z.output<Response>) => Result$1;
-  }): ((params: Util_FlatObject<QueryArgs<Url, QuerySchema, RequestSchema>>) => UseSuspenseQueryOptions<Result$1, Error, Result$1, DataTag<Split<Url, '/'>, Result$1, Error>>) & QueryHelpers<Url, QuerySchema, Result$1, false, RequestSchema> & EndpointHelper<Method, Url, RequestSchema, Response, QuerySchema>;
-  infiniteQuery<Method extends 'GET' | 'HEAD' | 'OPTIONS' = 'GET', Url extends string = string, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, PageResult = z.output<Response>, Result$1 = InfiniteData<PageResult>>(config: {
-    method: Method;
-    url: Url;
-    querySchema: QuerySchema;
-    responseSchema: Response;
-    processResponse?: (data: z.output<Response>) => PageResult;
-    getNextPageParam: (lastPage: PageResult, allPages: PageResult[], lastPageParam: z.infer<QuerySchema> | undefined, allPageParams: z.infer<QuerySchema>[] | undefined) => z.input<QuerySchema> | undefined;
-    getPreviousPageParam?: (firstPage: PageResult, allPages: PageResult[], lastPageParam: z.infer<QuerySchema> | undefined, allPageParams: z.infer<QuerySchema>[] | undefined) => z.input<QuerySchema>;
-  }): ((params: Util_FlatObject<QueryArgs<Url, QuerySchema>>) => UseSuspenseInfiniteQueryOptions<PageResult, Error, Result$1, DataTag<Split<Url, '/'>, PageResult, Error>, z.output<QuerySchema>>) & QueryHelpers<Url, QuerySchema, PageResult, true> & EndpointHelper<Method, Url, undefined, Response, QuerySchema>;
-  infiniteQuery<Method extends 'POST' = 'POST', Url extends string = string, QuerySchema extends ZodObject = ZodObject, RequestSchema extends ZodType = ZodType, Response extends ZodType = ZodType, PageResult = z.output<Response>, Result$1 = InfiniteData<PageResult>>(config: {
-    method: Method;
-    url: Url;
-    querySchema: QuerySchema;
-    requestSchema: RequestSchema;
-    responseSchema: Response;
-    processResponse?: (data: z.output<Response>) => PageResult;
-    getNextPageParam: (lastPage: PageResult, allPages: PageResult[], lastPageParam: z.infer<QuerySchema> | undefined, allPageParams: z.infer<QuerySchema>[] | undefined) => z.input<QuerySchema> | undefined;
-    getPreviousPageParam?: (firstPage: PageResult, allPages: PageResult[], lastPageParam: z.infer<QuerySchema> | undefined, allPageParams: z.infer<QuerySchema>[] | undefined) => z.input<QuerySchema>;
-  }): ((params: Util_FlatObject<QueryArgs<Url, QuerySchema, RequestSchema>>) => UseSuspenseInfiniteQueryOptions<PageResult, Error, Result$1, DataTag<Split<Url, '/'>, PageResult, Error>, z.output<QuerySchema>>) & QueryHelpers<Url, QuerySchema, PageResult, true, RequestSchema> & EndpointHelper<Method, Url, RequestSchema, Response, QuerySchema>;
-  mutation<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown, UseKey extends true = true>(config: {
+    responseSchema: ResponseSchema;
+    errorSchema: ErrorSchema;
+    urlParamsSchema: UrlParamsSchema;
+  }>(config: MutationEndpointConfig<UseDiscriminator, Method, Url, QuerySchema, RequestSchema, ResponseSchema, ErrorSchema, UrlParamsSchema, UseKey, TBaseResult, Result$1, OnMutateResult, Context, Variables>): ((...args: UseKey extends true ? UrlHasParams<Url> extends true ? [{
+    urlParams: UrlParams<Url>;
+  }] : [{}] : []) => UseMutationResult<Result$1, Error, Variables, OnMutateResult>) & (UseKey extends true ? MutationHelpers<Url, Result$1> : {}) & EndpointHelper<Options, UseDiscriminator>;
+}
+//#endregion
+//#region src/client/types/multipart-mutation.d.mts
+/**
+ * Multipart mutation method overloads for ClientInstance.
+ *
+ * @template UseDiscriminator - When `true`, errors are returned as union types.
+ *   When `false` (default), errors are thrown and not included in TData.
+ */
+interface ClientMultipartMutationMethods<UseDiscriminator extends boolean = false> {
+  multipartMutation<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, ErrorSchema extends ErrorSchemaRecord | undefined = undefined, TBaseResult = ComputeBaseResult<UseDiscriminator, Response, ErrorSchema>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown, UseKey extends true = true>(config: {
     method: Method;
     url: Url;
     useKey: UseKey;
     requestSchema: RequestSchema;
     querySchema: QuerySchema;
     responseSchema: Response;
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
+    errorSchema?: ErrorSchema;
+    processResponse: (data: TBaseResult) => Result$1 | Promise<Result$1>;
     useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
+    onMutate?: (variables: Simplify<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
+    onSuccess?: (data: NoInfer<Result$1>, variables: Simplify<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
       onMutateResult: OnMutateResult | undefined;
     }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
+    onError?: (error: Error, variables: Simplify<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
       onMutateResult: OnMutateResult | undefined;
     }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
+    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Simplify<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
       onMutateResult: OnMutateResult | undefined;
     }) => void | Promise<void>;
   }): ((params: UrlHasParams<Url> extends true ? {
     urlParams: UrlParams<Url>;
   } : {}) => UseMutationResult<Result$1, Error, MutationArgs<Url, RequestSchema, QuerySchema>, OnMutateResult>) & MutationHelpers<Url, Result$1> & EndpointHelper<Method, Url, RequestSchema, Response, QuerySchema>;
-  mutation<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown>(config: {
+  multipartMutation<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, ErrorSchema extends ErrorSchemaRecord | undefined = undefined, TBaseResult = ComputeBaseResult<UseDiscriminator, Response, ErrorSchema>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown>(config: {
     method: Method;
     url: Url;
     requestSchema: RequestSchema;
     querySchema: QuerySchema;
     responseSchema: Response;
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
+    errorSchema?: ErrorSchema;
+    processResponse: (data: TBaseResult) => Result$1 | Promise<Result$1>;
     useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
+    onMutate?: (variables: Simplify<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
+    onSuccess?: (data: NoInfer<Result$1>, variables: Simplify<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
       onMutateResult: OnMutateResult | undefined;
     }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
+    onError?: (error: Error, variables: Simplify<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
       onMutateResult: OnMutateResult | undefined;
     }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
+    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Simplify<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
       onMutateResult: OnMutateResult | undefined;
     }) => void | Promise<void>;
   }): (() => UseMutationResult<Result$1, Error, MutationArgs<Url, RequestSchema, QuerySchema>, OnMutateResult>) & MutationHelpers<Url, Result$1> & EndpointHelper<Method, Url, RequestSchema, Response, QuerySchema>;
-  mutation<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown>(config: {
+  multipartMutation<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, Response extends ZodType = ZodType, ErrorSchema extends ErrorSchemaRecord | undefined = undefined, TBaseResult = ComputeBaseResult<UseDiscriminator, Response, ErrorSchema>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown>(config: {
     method: Method;
     url: Url;
     requestSchema: RequestSchema;
     responseSchema: Response;
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
+    errorSchema?: ErrorSchema;
+    processResponse: (data: TBaseResult) => Result$1 | Promise<Result$1>;
     useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
+    onMutate?: (variables: Simplify<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
+    onSuccess?: (data: NoInfer<Result$1>, variables: Simplify<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
       onMutateResult: OnMutateResult | undefined;
     }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
+    onError?: (error: Error, variables: Simplify<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
       onMutateResult: OnMutateResult | undefined;
     }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
+    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Simplify<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
       onMutateResult: OnMutateResult | undefined;
     }) => void | Promise<void>;
   }): (() => UseMutationResult<Result$1, Error, MutationArgs<Url, RequestSchema, undefined>, OnMutateResult>) & MutationHelpers<Url, Result$1> & EndpointHelper<Method, Url, RequestSchema, Response>;
-  mutation<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown, UseKey extends true = true>(config: {
+  multipartMutation<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, Response extends ZodType = ZodType, ErrorSchema extends ErrorSchemaRecord | undefined = undefined, TBaseResult = ComputeBaseResult<UseDiscriminator, Response, ErrorSchema>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown, UseKey extends true = true>(config: {
     method: Method;
     url: Url;
     useKey: UseKey;
     requestSchema: RequestSchema;
     responseSchema: Response;
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
+    errorSchema?: ErrorSchema;
+    processResponse: (data: TBaseResult) => Result$1 | Promise<Result$1>;
     useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
+    onMutate?: (variables: Simplify<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
+    onSuccess?: (data: NoInfer<Result$1>, variables: Simplify<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
       onMutateResult: OnMutateResult | undefined;
     }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
+    onError?: (error: Error, variables: Simplify<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
       onMutateResult: OnMutateResult | undefined;
     }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
+    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Simplify<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
       onMutateResult: OnMutateResult | undefined;
     }) => void | Promise<void>;
   }): ((params: UrlHasParams<Url> extends true ? {
     urlParams: UrlParams<Url>;
   } : {}) => UseMutationResult<Result$1, Error, MutationArgs<Url, RequestSchema, undefined>, OnMutateResult>) & MutationHelpers<Url, Result$1> & EndpointHelper<Method, Url, RequestSchema, Response>;
-  mutation<Method extends 'DELETE' = 'DELETE', Url extends string = string, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown, UseKey extends true = true>(config: {
-    method: Method;
-    url: Url;
-    useKey: UseKey;
-    querySchema: QuerySchema;
-    responseSchema: Response;
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): ((params: UrlHasParams<Url> extends true ? {
-    urlParams: UrlParams<Url>;
-  } : {}) => UseMutationResult<Result$1, Error, MutationArgs<Url, undefined, QuerySchema>, OnMutateResult>) & MutationHelpers<Url, Result$1> & EndpointHelper<Method, Url, undefined, Response, QuerySchema>;
-  mutation<Method extends 'DELETE' = 'DELETE', Url extends string = string, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown>(config: {
-    method: Method;
-    url: Url;
-    querySchema: QuerySchema;
-    responseSchema: Response;
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): (() => UseMutationResult<Result$1, Error, MutationArgs<Url, undefined, QuerySchema>, OnMutateResult>) & MutationHelpers<Url, Result$1> & EndpointHelper<Method, Url, undefined, Response, QuerySchema>;
-  mutation<Method extends 'DELETE' = 'DELETE', Url extends string = string, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown, UseKey extends true = true>(config: {
-    method: Method;
-    url: Url;
-    useKey: UseKey;
-    responseSchema: Response;
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): ((params: UrlHasParams<Url> extends true ? {
-    urlParams: UrlParams<Url>;
-  } : {}) => UseMutationResult<Result$1, Error, MutationArgs<Url, undefined, undefined>, OnMutateResult>) & MutationHelpers<Url, Result$1> & EndpointHelper<Method, Url, undefined, Response>;
-  mutation<Method extends 'DELETE' = 'DELETE', Url extends string = string, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown>(config: {
-    method: Method;
-    url: Url;
-    responseSchema: Response;
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): (() => UseMutationResult<Result$1, Error, MutationArgs<Url, undefined, undefined>, OnMutateResult>) & MutationHelpers<Url, Result$1> & EndpointHelper<Method, Url, undefined, Response>;
-  queryFromEndpoint<Method extends 'GET' | 'HEAD' | 'OPTIONS' = 'GET', Url extends string = string, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, Result$1 = z.output<Response>>(endpoint: {
-    config: BaseEndpointConfig<Method, Url, QuerySchema, Response>;
-  }, options?: {
-    processResponse?: (data: z.output<Response>) => Result$1;
-  }): (params: Util_FlatObject<QueryArgs<Url, QuerySchema>>) => UseSuspenseQueryOptions<Result$1, Error, Result$1, DataTag<Split<Url, '/'>, Result$1, Error>> & QueryHelpers<Url, QuerySchema, Result$1>;
-  queryFromEndpoint<Method extends 'GET' | 'HEAD' | 'OPTIONS' = 'GET', Url extends string = string, Response extends ZodType = ZodType, Result$1 = z.output<Response>>(endpoint: {
-    config: BaseEndpointConfig<Method, Url, undefined, Response>;
+}
+//#endregion
+//#region src/client/types/from-endpoint.d.mts
+/**
+ * Helper type to extract useKey from mutation options
+ */
+type ExtractUseKey<Options> = Options extends {
+  useKey: infer U;
+} ? U extends true ? true : false : false;
+/**
+ * FromEndpoint methods using const generics pattern (simplified from multiple overloads).
+ *
+ * @template UseDiscriminator - When `true`, errors are returned as union types.
+ *   When `false` (default), errors are thrown and not included in TData.
+ */
+interface ClientFromEndpointMethods<UseDiscriminator extends boolean = false> {
+  /**
+   * Creates a type-safe query from an existing endpoint with automatic type inference.
+   *
+   * Uses const generic pattern to infer types from the endpoint configuration.
+   *
+   * @example
+   * ```ts
+   * const getUserEndpoint = api.declareEndpoint({
+   *   method: 'GET',
+   *   url: '/users/$userId',
+   *   responseSchema: userSchema,
+   * })
+   *
+   * const getUser = client.queryFromEndpoint(getUserEndpoint, {
+   *   processResponse: (data) => data,
+   * })
+   * ```
+   */
+  queryFromEndpoint<const Config extends EndpointOptions, TBaseResult = ComputeBaseResult<UseDiscriminator, Config['responseSchema'], Config['errorSchema']>, Result$1 = TBaseResult>(endpoint: {
+    config: Config;
   }, options?: {
-    processResponse?: (data: z.output<Response>) => Result$1;
-  }): ((params: Util_FlatObject<QueryArgs<Url, undefined>>) => UseSuspenseQueryOptions<Result$1, Error, Result$1, DataTag<Split<Url, '/'>, Result$1, Error>>) & QueryHelpers<Url, undefined, Result$1>;
-  infiniteQueryFromEndpoint<Method extends 'GET' | 'HEAD' | 'OPTIONS' = 'GET', Url extends string = string, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, PageResult = z.output<Response>, Result$1 = InfiniteData<PageResult>>(endpoint: {
-    config: BaseEndpointConfig<Method, Url, QuerySchema, Response>;
+    processResponse?: (data: TBaseResult) => Result$1;
+  }): ((params: Simplify<InferEndpointParams<Config>>) => UseSuspenseQueryOptions<Result$1, Error, Result$1, DataTag<Split<Config['url'], '/'>, Result$1, Error>>) & QueryHelpers<Config['url'], Config['querySchema'] extends ZodObject ? Config['querySchema'] : undefined, Result$1, false, Config['requestSchema'] extends ZodType ? Config['requestSchema'] : undefined>;
+  /**
+   * Creates a type-safe infinite query from an existing endpoint with automatic type inference.
+   *
+   * Uses const generic pattern to infer types from the endpoint configuration.
+   *
+   * @example
+   * ```ts
+   * const getUsersEndpoint = api.declareEndpoint({
+   *   method: 'GET',
+   *   url: '/users',
+   *   querySchema: z.object({ page: z.number() }),
+   *   responseSchema: z.array(userSchema),
+   * })
+   *
+   * const getUsers = client.infiniteQueryFromEndpoint(getUsersEndpoint, {
+   *   getNextPageParam: (lastPage, allPages, lastPageParam) => {
+   *     return lastPage.length > 0 ? { page: (lastPageParam?.page ?? 0) + 1 } : undefined
+   *   },
+   * })
+   * ```
+   */
+  infiniteQueryFromEndpoint<const Config extends EndpointOptions & {
+    querySchema: ZodObject;
+  }, TBaseResult = ComputeBaseResult<UseDiscriminator, Config['responseSchema'], Config['errorSchema']>, PageResult = TBaseResult, Result$1 = InfiniteData<PageResult>>(endpoint: {
+    config: Config;
   }, options: {
-    processResponse?: (data: z.output<Response>) => PageResult;
-    getNextPageParam: (lastPage: PageResult, allPages: PageResult[], lastPageParam: z.infer<QuerySchema> | undefined, allPageParams: z.infer<QuerySchema>[] | undefined) => z.input<QuerySchema> | undefined;
-    getPreviousPageParam?: (firstPage: PageResult, allPages: PageResult[], lastPageParam: z.infer<QuerySchema> | undefined, allPageParams: z.infer<QuerySchema>[] | undefined) => z.input<QuerySchema>;
-  }): ((params: Util_FlatObject<QueryArgs<Url, QuerySchema>>) => UseSuspenseInfiniteQueryOptions<PageResult, Error, Result$1, DataTag<Split<Url, '/'>, PageResult, Error>, z.output<QuerySchema>>) & QueryHelpers<Url, QuerySchema, PageResult, true>;
-  mutationFromEndpoint<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown, UseKey extends true = true>(endpoint: {
-    config: BaseEndpointConfig<Method, Url, QuerySchema, Response, RequestSchema>;
-  }, mutationOptions: {
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
-    useKey: UseKey;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): ((params: UrlHasParams<Url> extends true ? {
-    urlParams: UrlParams<Url>;
-  } : {}) => UseMutationResult<Result$1, Error, MutationArgs<Url, RequestSchema, QuerySchema>, OnMutateResult>) & MutationHelpers<Url, Result$1> & EndpointHelper<Method, Url, RequestSchema, Response, QuerySchema>;
-  mutationFromEndpoint<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown, UseKey extends true = true>(endpoint: {
-    config: BaseEndpointConfig<Method, Url, undefined, Response, RequestSchema>;
-  }, mutationOptions: {
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
-    useKey: UseKey;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): ((params: UrlHasParams<Url> extends true ? {
-    urlParams: UrlParams<Url>;
-  } : {}) => UseMutationResult<Result$1, Error, MutationArgs<Url, RequestSchema, undefined>, OnMutateResult>) & MutationHelpers<Url, Result$1> & EndpointHelper<Method, Url, RequestSchema, Response, undefined>;
-  mutationFromEndpoint<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown>(endpoint: {
-    config: BaseEndpointConfig<Method, Url, QuerySchema, Response, RequestSchema>;
-  }, mutationOptions: {
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): (() => UseMutationResult<Result$1, Error, MutationArgs<Url, RequestSchema, QuerySchema>, OnMutateResult>) & EndpointHelper<Method, Url, RequestSchema, Response, QuerySchema>;
-  mutationFromEndpoint<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown>(endpoint: {
-    config: BaseEndpointConfig<Method, Url, undefined, Response, RequestSchema>;
-  }, mutationOptions: {
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): (() => UseMutationResult<Result$1, Error, MutationArgs<Url, RequestSchema, undefined>, OnMutateResult>) & EndpointHelper<Method, Url, RequestSchema, Response, undefined>;
-  mutationFromEndpoint<Method extends 'DELETE' = 'DELETE', Url extends string = string, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown, UseKey extends true = true>(endpoint: {
-    config: BaseEndpointConfig<Method, Url, QuerySchema, Response>;
-  }, mutationOptions: {
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
-    useKey: UseKey;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): (() => UseMutationResult<Result$1, Error, MutationArgs<Url, undefined, QuerySchema>, OnMutateResult>) & MutationHelpers<Url, Result$1> & EndpointHelper<Method, Url, undefined, Response, QuerySchema>;
-  mutationFromEndpoint<Method extends 'DELETE' = 'DELETE', Url extends string = string, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown, UseKey extends true = true>(endpoint: {
-    config: BaseEndpointConfig<Method, Url, undefined, Response>;
-  }, mutationOptions: {
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
-    useKey: UseKey;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): ((params: UrlHasParams<Url> extends true ? {
-    urlParams: UrlParams<Url>;
-  } : {}) => UseMutationResult<Result$1, Error, MutationArgs<Url, undefined, undefined>, OnMutateResult>) & MutationHelpers<Url, Result$1> & EndpointHelper<Method, Url, undefined, Response, undefined>;
-  mutationFromEndpoint<Method extends 'DELETE' = 'DELETE', Url extends string = string, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown>(endpoint: {
-    config: BaseEndpointConfig<Method, Url, QuerySchema, Response>;
-  }, mutationOptions: {
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): (() => UseMutationResult<Result$1, Error, MutationArgs<Url, undefined, QuerySchema>, OnMutateResult>) & EndpointHelper<Method, Url, undefined, Response, QuerySchema>;
-  mutationFromEndpoint<Method extends 'DELETE' = 'DELETE', Url extends string = string, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown>(endpoint: {
-    config: BaseEndpointConfig<Method, Url, undefined, Response>;
-  }, mutationOptions: {
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): (() => UseMutationResult<Result$1, Error, MutationArgs<Url, undefined, undefined>, OnMutateResult>) & EndpointHelper<Method, Url, undefined, Response, undefined>;
-  multipartMutation<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown, UseKey extends true = true>(config: {
-    method: Method;
-    url: Url;
-    useKey: UseKey;
-    requestSchema: RequestSchema;
-    querySchema: QuerySchema;
-    responseSchema: Response;
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): ((params: UrlHasParams<Url> extends true ? {
-    urlParams: UrlParams<Url>;
-  } : {}) => UseMutationResult<Result$1, Error, MutationArgs<Url, RequestSchema, QuerySchema>, OnMutateResult>) & MutationHelpers<Url, Result$1> & EndpointHelper<Method, Url, RequestSchema, Response, QuerySchema>;
-  multipartMutation<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown>(config: {
-    method: Method;
-    url: Url;
-    requestSchema: RequestSchema;
-    querySchema: QuerySchema;
-    responseSchema: Response;
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): (() => UseMutationResult<Result$1, Error, MutationArgs<Url, RequestSchema, QuerySchema>, OnMutateResult>) & MutationHelpers<Url, Result$1> & EndpointHelper<Method, Url, RequestSchema, Response, QuerySchema>;
-  multipartMutation<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown>(config: {
-    method: Method;
-    url: Url;
-    requestSchema: RequestSchema;
-    responseSchema: Response;
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): (() => UseMutationResult<Result$1, Error, MutationArgs<Url, RequestSchema, undefined>, OnMutateResult>) & MutationHelpers<Url, Result$1> & EndpointHelper<Method, Url, RequestSchema, Response>;
-  multipartMutation<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, OnMutateResult = unknown, Context = unknown, UseKey extends true = true>(config: {
-    method: Method;
-    url: Url;
-    useKey: UseKey;
-    requestSchema: RequestSchema;
-    responseSchema: Response;
-    processResponse: ProcessResponseFunction<Result$1, ReqResult>;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): ((params: UrlHasParams<Url> extends true ? {
-    urlParams: UrlParams<Url>;
-  } : {}) => UseMutationResult<Result$1, Error, MutationArgs<Url, RequestSchema, undefined>, OnMutateResult>) & MutationHelpers<Url, Result$1> & EndpointHelper<Method, Url, RequestSchema, Response>;
-  mutationFromEndpoint<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, QuerySchema extends ZodObject = ZodObject, Result$1 = Blob, OnMutateResult = unknown, Context = unknown, UseKey extends true = true>(endpoint: {
-    config: BaseStreamConfig<Method, Url, QuerySchema, RequestSchema>;
-  }, mutationOptions: {
-    processResponse?: ProcessResponseFunction<Result$1, Blob>;
-    useKey: UseKey;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): ((params: UrlHasParams<Url> extends true ? {
-    urlParams: UrlParams<Url>;
-  } : {}) => UseMutationResult<Result$1, Error, MutationArgs<Url, RequestSchema, QuerySchema>, OnMutateResult>) & MutationHelpers<Url, Result$1> & StreamHelper<Method, Url, RequestSchema, QuerySchema>;
-  mutationFromEndpoint<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, QuerySchema extends ZodObject = ZodObject, Result$1 = Blob, OnMutateResult = unknown, Context = unknown>(endpoint: {
-    config: BaseStreamConfig<Method, Url, QuerySchema, RequestSchema>;
-  }, mutationOptions?: {
-    processResponse?: ProcessResponseFunction<Result$1, Blob>;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): (() => UseMutationResult<Result$1, Error, MutationArgs<Url, RequestSchema, QuerySchema>, OnMutateResult>) & StreamHelper<Method, Url, RequestSchema, QuerySchema>;
-  mutationFromEndpoint<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, Result$1 = Blob, OnMutateResult = unknown, Context = unknown, UseKey extends true = true>(endpoint: {
-    config: BaseStreamConfig<Method, Url, undefined, RequestSchema>;
-  }, mutationOptions: {
-    processResponse?: ProcessResponseFunction<Result$1, Blob>;
-    useKey: UseKey;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): ((params: UrlHasParams<Url> extends true ? {
-    urlParams: UrlParams<Url>;
-  } : {}) => UseMutationResult<Result$1, Error, MutationArgs<Url, RequestSchema, undefined>, OnMutateResult>) & MutationHelpers<Url, Result$1> & StreamHelper<Method, Url, RequestSchema, undefined>;
-  mutationFromEndpoint<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, Result$1 = Blob, OnMutateResult = unknown, Context = unknown>(endpoint: {
-    config: BaseStreamConfig<Method, Url, undefined, RequestSchema>;
-  }, mutationOptions?: {
-    processResponse?: ProcessResponseFunction<Result$1, Blob>;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): (() => UseMutationResult<Result$1, Error, MutationArgs<Url, RequestSchema, undefined>, OnMutateResult>) & StreamHelper<Method, Url, RequestSchema, undefined>;
-  mutationFromEndpoint<Method extends 'GET' | 'DELETE' | 'OPTIONS' | 'HEAD' = 'GET', Url extends string = string, QuerySchema extends ZodObject = ZodObject, Result$1 = Blob, OnMutateResult = unknown, Context = unknown, UseKey extends true = true>(endpoint: {
-    config: BaseStreamConfig<Method, Url, QuerySchema, undefined>;
-  }, mutationOptions: {
-    processResponse?: ProcessResponseFunction<Result$1, Blob>;
-    useKey: UseKey;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): ((params: UrlHasParams<Url> extends true ? {
-    urlParams: UrlParams<Url>;
-  } : {}) => UseMutationResult<Result$1, Error, MutationArgs<Url, undefined, QuerySchema>, OnMutateResult>) & MutationHelpers<Url, Result$1> & StreamHelper<Method, Url, undefined, QuerySchema>;
-  mutationFromEndpoint<Method extends 'GET' | 'DELETE' | 'OPTIONS' | 'HEAD' = 'GET', Url extends string = string, QuerySchema extends ZodObject = ZodObject, Result$1 = Blob, OnMutateResult = unknown, Context = unknown>(endpoint: {
-    config: BaseStreamConfig<Method, Url, QuerySchema, undefined>;
-  }, mutationOptions?: {
-    processResponse?: ProcessResponseFunction<Result$1, Blob>;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): (() => UseMutationResult<Result$1, Error, MutationArgs<Url, undefined, QuerySchema>, OnMutateResult>) & StreamHelper<Method, Url, undefined, QuerySchema>;
-  mutationFromEndpoint<Method extends 'GET' | 'DELETE' | 'OPTIONS' | 'HEAD' = 'GET', Url extends string = string, Result$1 = Blob, OnMutateResult = unknown, Context = unknown, UseKey extends true = true>(endpoint: {
-    config: BaseStreamConfig<Method, Url, undefined, undefined>;
-  }, mutationOptions: {
-    processResponse?: ProcessResponseFunction<Result$1, Blob>;
-    useKey: UseKey;
-    useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): ((params: UrlHasParams<Url> extends true ? {
-    urlParams: UrlParams<Url>;
-  } : {}) => UseMutationResult<Result$1, Error, MutationArgs<Url, undefined, undefined>, OnMutateResult>) & MutationHelpers<Url, Result$1> & StreamHelper<Method, Url, undefined, undefined>;
-  mutationFromEndpoint<Method extends 'GET' | 'DELETE' | 'OPTIONS' | 'HEAD' = 'GET', Url extends string = string, Result$1 = Blob, OnMutateResult = unknown, Context = unknown>(endpoint: {
-    config: BaseStreamConfig<Method, Url, undefined, undefined>;
+    processResponse?: (data: TBaseResult) => PageResult;
+    getNextPageParam: (lastPage: PageResult, allPages: PageResult[], lastPageParam: z.infer<Config['querySchema']> | undefined, allPageParams: z.infer<Config['querySchema']>[] | undefined) => z.input<Config['querySchema']> | undefined;
+    getPreviousPageParam?: (firstPage: PageResult, allPages: PageResult[], lastPageParam: z.infer<Config['querySchema']> | undefined, allPageParams: z.infer<Config['querySchema']>[] | undefined) => z.input<Config['querySchema']>;
+  }): ((params: Simplify<InferEndpointParams<Config>>) => UseSuspenseInfiniteQueryOptions<PageResult, Error, Result$1, DataTag<Split<Config['url'], '/'>, PageResult, Error>, z.output<Config['querySchema']>>) & QueryHelpers<Config['url'], Config['querySchema'], PageResult, true, Config['requestSchema'] extends ZodType ? Config['requestSchema'] : undefined>;
+  /**
+   * Creates a type-safe mutation from an existing endpoint with automatic type inference.
+   *
+   * Uses const generic pattern to infer types from the endpoint configuration.
+   * Handles both regular endpoints and stream endpoints.
+   *
+   * @example
+   * ```ts
+   * const createUserEndpoint = api.declareEndpoint({
+   *   method: 'POST',
+   *   url: '/users',
+   *   requestSchema: createUserSchema,
+   *   responseSchema: userSchema,
+   * })
+   *
+   * const createUser = client.mutationFromEndpoint(createUserEndpoint, {
+   *   processResponse: (data) => data,
+   * })
+   * ```
+   */
+  mutationFromEndpoint<const Config extends EndpointOptions | BaseEndpointOptions, TBaseResult = (Config extends EndpointOptions ? ComputeBaseResult<UseDiscriminator, Config['responseSchema'], Config['errorSchema']> : Blob), Result$1 = (Config extends EndpointOptions ? ComputeBaseResult<UseDiscriminator, Config['responseSchema'], Config['errorSchema']> : Blob), OnMutateResult = unknown, Context = unknown>(endpoint: {
+    config: Config;
   }, mutationOptions?: {
-    processResponse?: ProcessResponseFunction<Result$1, Blob>;
+    processResponse?: (data: TBaseResult) => Result$1 | Promise<Result$1>;
     useContext?: () => Context;
-    onMutate?: (variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
-    onSuccess?: (data: NoInfer<Result$1>, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onError?: (error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context & MutationFunctionContext & {
-      onMutateResult: OnMutateResult | undefined;
-    }) => void | Promise<void>;
-  }): (() => UseMutationResult<Result$1, Error, MutationArgs<Url, undefined, undefined>, OnMutateResult>) & StreamHelper<Method, Url, undefined, undefined>;
+    useKey?: boolean;
+    onMutate?: (variables: Simplify<RequestArgs<Config['url'], Config['querySchema'] extends ZodObject ? Config['querySchema'] : undefined, Config['requestSchema'] extends ZodType ? Config['requestSchema'] : undefined, Config['urlParamsSchema'] extends ZodObject ? Config['urlParamsSchema'] : undefined>>, context: Context & MutationFunctionContext) => OnMutateResult | Promise<OnMutateResult>;
+    onSuccess?: (data: NoInfer<Result$1>, variables: Simplify<RequestArgs<Config['url'], Config['querySchema'] extends ZodObject ? Config['querySchema'] : undefined, Config['requestSchema'] extends ZodType ? Config['requestSchema'] : undefined, Config['urlParamsSchema'] extends ZodObject ? Config['urlParamsSchema'] : undefined>>, context: Context & MutationFunctionContext & {
+      onMutateResult: OnMutateResult | undefined;
+    }) => void | Promise<void>;
+    onError?: (error: Error, variables: Simplify<RequestArgs<Config['url'], Config['querySchema'] extends ZodObject ? Config['querySchema'] : undefined, Config['requestSchema'] extends ZodType ? Config['requestSchema'] : undefined, Config['urlParamsSchema'] extends ZodObject ? Config['urlParamsSchema'] : undefined>>, context: Context & MutationFunctionContext & {
+      onMutateResult: OnMutateResult | undefined;
+    }) => void | Promise<void>;
+    onSettled?: (data: NoInfer<Result$1> | undefined, error: Error | null, variables: Simplify<RequestArgs<Config['url'], Config['querySchema'] extends ZodObject ? Config['querySchema'] : undefined, Config['requestSchema'] extends ZodType ? Config['requestSchema'] : undefined, Config['urlParamsSchema'] extends ZodObject ? Config['urlParamsSchema'] : undefined>>, context: Context & MutationFunctionContext & {
+      onMutateResult: OnMutateResult | undefined;
+    }) => void | Promise<void>;
+  }): ((...args: ExtractUseKey<typeof mutationOptions> extends true ? UrlHasParams<Config['url']> extends true ? [{
+    urlParams: UrlParams<Config['url']>;
+  }] : [] : []) => UseMutationResult<Result$1, Error, Simplify<RequestArgs<Config['url'], Config['querySchema'] extends ZodObject ? Config['querySchema'] : undefined, Config['requestSchema'] extends ZodType ? Config['requestSchema'] : undefined, Config['urlParamsSchema'] extends ZodObject ? Config['urlParamsSchema'] : undefined>>, OnMutateResult>) & (ExtractUseKey<typeof mutationOptions> extends true ? MutationHelpers<Config['url'], Result$1> : {}) & (Config extends EndpointOptions ? EndpointHelper<{
+    method: Config['method'];
+    url: Config['url'];
+    responseSchema: Config['responseSchema'];
+    querySchema: Config['querySchema'];
+    requestSchema: Config['requestSchema'];
+    errorSchema: Config['errorSchema'];
+    urlParamsSchema: Config['urlParamsSchema'];
+  }, UseDiscriminator> : StreamHelper<{
+    method: Config['method'];
+    url: Config['url'];
+    querySchema: Config['querySchema'];
+    requestSchema: Config['requestSchema'];
+    errorSchema: Config['errorSchema'];
+    urlParamsSchema: Config['urlParamsSchema'];
+  }, UseDiscriminator>);
 }
 //#endregion
+//#region src/client/types/index.d.mts
+/**
+ * The main client instance interface.
+ * Provides methods for creating queries, infinite queries, and mutations.
+ *
+ * @template UseDiscriminator - When `true`, errors are returned as union types.
+ *   When `false` (default), errors are thrown and not included in TData.
+ */
+interface ClientInstance<UseDiscriminator extends boolean = false> extends ClientQueryMethods<UseDiscriminator>, ClientInfiniteQueryMethods<UseDiscriminator>, ClientMutationMethods<UseDiscriminator>, ClientMultipartMutationMethods<UseDiscriminator>, ClientFromEndpointMethods<UseDiscriminator> {}
+//#endregion
 //#region src/client/declare-client.d.mts
 /**
  * Configuration for declaring a query endpoint.
  */
-interface QueryConfig<Method = HttpMethod, Url = string, QuerySchema = ZodObject, Response extends ZodType = ZodType, Result$1 = z.output<Response>, RequestSchema = unknown> {
+interface QueryConfig<Method extends HttpMethod = HttpMethod, Url extends string = string, QuerySchema extends ZodObject | undefined = undefined, Response extends ZodType = ZodType, ErrorSchema extends ErrorSchemaRecord | undefined = undefined, Result$1 = ComputeBaseResult<true, Response, ErrorSchema>, RequestSchema extends ZodType | undefined = undefined> {
   method: Method;
   url: Url;
   querySchema?: QuerySchema;
   responseSchema: Response;
+  errorSchema?: ErrorSchema;
   requestSchema?: RequestSchema;
-  processResponse?: (data: z.output<Response>) => Result$1;
+  processResponse?: (data: ComputeBaseResult<true, Response, ErrorSchema>) => Result$1;
 }
 /**
  * Configuration for declaring an infinite query endpoint.
  */
-type InfiniteQueryConfig<Method = HttpMethod, Url = string, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, PageResult = z.output<Response>, Result$1 = InfiniteData<PageResult>, RequestSchema = unknown> = {
+type InfiniteQueryConfig<Method extends HttpMethod = HttpMethod, Url extends string = string, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, ErrorSchema extends ErrorSchemaRecord | undefined = undefined, PageResult = ComputeBaseResult<true, Response, ErrorSchema>, Result$1 = InfiniteData<PageResult>, RequestSchema extends ZodType | undefined = undefined> = {
   method: Method;
   url: Url;
   querySchema: QuerySchema;
   responseSchema: Response;
+  errorSchema?: ErrorSchema;
   requestSchema?: RequestSchema;
-  processResponse?: (data: z.output<Response>) => PageResult;
+  processResponse?: (data: ComputeBaseResult<true, Response, ErrorSchema>) => PageResult;
   select?: (data: InfiniteData<PageResult>) => Result$1;
   getNextPageParam: (lastPage: PageResult, allPages: PageResult[], lastPageParam: z.infer<QuerySchema> | undefined, allPageParams: z.infer<QuerySchema>[] | undefined) => z.input<QuerySchema> | undefined;
   getPreviousPageParam?: (firstPage: PageResult, allPages: PageResult[], lastPageParam: z.infer<QuerySchema> | undefined, allPageParams: z.infer<QuerySchema>[] | undefined) => z.input<QuerySchema>;
@@ -910,11 +1325,12 @@ type InfiniteQueryConfig<Method = HttpMethod, Url = string, QuerySchema extends
 /**
  * Configuration for declaring a mutation endpoint.
  */
-interface MutationConfig<Method extends 'POST' | 'PUT' | 'PATCH' | 'DELETE' = 'POST' | 'PUT' | 'PATCH' | 'DELETE', Url extends string = string, RequestSchema = (Method extends 'DELETE' ? never : ZodObject), QuerySchema = unknown, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result$1 = unknown, TOnMutateResult = unknown, Context = unknown, UseKey extends boolean = false> {
+interface MutationConfig<Method extends 'POST' | 'PUT' | 'PATCH' | 'DELETE' = 'POST' | 'PUT' | 'PATCH' | 'DELETE', Url extends string = string, RequestSchema extends ZodType | undefined = (Method extends 'DELETE' ? undefined : ZodType), QuerySchema extends ZodObject | undefined = undefined, Response extends ZodType = ZodType, ErrorSchema extends ErrorSchemaRecord | undefined = undefined, ReqResult = ComputeBaseResult<true, Response, ErrorSchema>, Result$1 = unknown, TOnMutateResult = unknown, Context = unknown, UseKey extends boolean = false> {
   method: Method;
   url: Url;
   querySchema?: QuerySchema;
   responseSchema: Response;
+  errorSchema?: ErrorSchema;
   requestSchema?: RequestSchema;
   processResponse: ProcessResponseFunction<Result$1, ReqResult>;
   useContext?: () => Context;
@@ -934,12 +1350,15 @@ interface MutationConfig<Method extends 'POST' | 'PUT' | 'PATCH' | 'DELETE' = 'P
 /**
  * Creates a client instance for making type-safe queries and mutations.
  *
+ * @template UseDiscriminator - When `true`, errors are returned as union types.
+ *   When `false` (default), errors are thrown and not included in TData.
+ *
  * @param options - Client configuration including the API builder and defaults
  * @returns A client instance with query, infiniteQuery, and mutation methods
  *
  * @example
  * ```typescript
- * const api = createBuilder({ baseUrl: '/api' });
+ * const api = builder({});
  * const client = declareClient({ api });
  *
  * const getUser = client.query({
@@ -952,10 +1371,10 @@ interface MutationConfig<Method extends 'POST' | 'PUT' | 'PATCH' | 'DELETE' = 'P
  * const { data } = useSuspenseQuery(getUser({ urlParams: { id: '123' } }));
  * ```
  */
-declare function declareClient<Options extends ClientOptions>({
+declare function declareClient<UseDiscriminator extends boolean = false>({
   api,
   defaults
-}: Options): ClientInstance;
+}: ClientOptions<UseDiscriminator>): ClientInstance<UseDiscriminator>;
 //#endregion
-export { BaseMutationArgs, BaseMutationParams, BaseQueryArgs, BaseQueryParams, ClientEndpointHelper, ClientInstance, ClientMutationArgs, ClientOptions, ClientQueryArgs, ClientQueryUrlParamsArgs, EndpointHelper, InfiniteQueryConfig, InfiniteQueryOptions, MutationArgs, MutationConfig, MutationHelpers, MutationParams, ProcessResponseFunction, QueryArgs, QueryConfig, QueryHelpers, QueryKeyCreatorResult, QueryParams, QueryUrlParamsArgs, Split, StreamHelper, createMutationKey, createQueryKey, declareClient, makeInfiniteQueryOptions, makeMutation, makeQueryOptions, mutationKeyCreator, queryKeyCreator };
+export { BaseMutationArgs, BaseMutationParams, BaseQueryArgs, BaseQueryParams, ClientEndpointHelper, ClientFromEndpointMethods, ClientInfiniteQueryMethods, ClientInstance, ClientMultipartMutationMethods, ClientMutationArgs, ClientMutationMethods, ClientOptions, ClientQueryArgs, ClientQueryMethods, ClientQueryUrlParamsArgs, ComputeBaseResult, ComputeResponseInput, ComputeResultType, EndpointHelper, InferEndpointResponse, InfiniteQueryConfig, InfiniteQueryOptions, MakeQueryOptionsParams, MutationArgs, MutationConfig, MutationHelpers, MutationParams, OptimisticUpdateCallbacks, OptimisticUpdateConfig, PrefetchHelper, ProcessResponseFunction, QueryArgs, QueryConfig, QueryHelpers, QueryKeyCreatorResult, QueryOptionsCreator, QueryParams, QueryResult, QueryUrlParamsArgs, ResponseDataType, Split, StreamHelper, createMultiOptimisticUpdate, createMutationKey, createOptimisticUpdate, createPrefetchHelper, createPrefetchHelpers, createQueryKey, declareClient, makeInfiniteQueryOptions, makeMutation, makeQueryOptions, mutationKeyCreator, prefetchAll, queryKeyCreator };
 //# sourceMappingURL=index.d.cts.map