@navios/react-query 0.4.0 → 0.5.0

package/lib/_tsup-dts-rollup.d.mts

@@ -8,8 +8,9 @@ import type { HttpMethod } from '@navios/builder';
 import type { InfiniteData } from '@tanstack/react-query';
 import type { NaviosZodRequest } from '@navios/builder';
 import { NoInfer as NoInfer_2 } from '@tanstack/react-query';
+import { ProcessResponseFunction as ProcessResponseFunction_2 } from '../index.mjs';
 import type { QueryClient } from '@tanstack/react-query';
-import { QueryKeyCreatorResult as QueryKeyCreatorResult_2 } from './utils/query-key-creator.mjs';
+import { QueryKeyCreatorResult as QueryKeyCreatorResult_2 } from './types.mjs';
 import { UrlHasParams } from '@navios/builder';
 import type { UrlParams } from '@navios/builder';
 import type { UseInfiniteQueryOptions } from '@tanstack/react-query';
@@ -27,29 +28,19 @@ import type { z } from 'zod/v4';
 import type { ZodObject } from 'zod/v4';
 import type { ZodType } from 'zod/v4';
 
+/** @deprecated Use NaviosZodRequest from @navios/builder instead */
 declare type BaseMutationArgs<Config extends AnyEndpointConfig> = NaviosZodRequest<Config>;
 export { BaseMutationArgs }
 export { BaseMutationArgs as BaseMutationArgs_alias_1 }
+export { BaseMutationArgs as BaseMutationArgs_alias_2 }
 
-declare interface BaseMutationParams<Config extends AnyEndpointConfig, TData = unknown, TVariables = BaseMutationArgs<Config>, TResponse = z.output<Config['responseSchema']>, TContext = unknown, UseKey extends boolean = false> extends Omit<UseMutationOptions<TData, Error, TVariables>, 'mutationKey' | 'mutationFn' | 'onSuccess' | 'onError' | 'scope'> {
-    processResponse: ProcessResponseFunction<TData, TResponse>;
-    /**
-     * 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?: (queryClient: QueryClient, data: TData, variables: TVariables, context: TContext) => void | Promise<void>;
-    onError?: (queryClient: QueryClient, err: unknown, variables: TVariables, context: TContext) => void | Promise<void>;
-    /**
-     * If true, we will create a mutation key that can be shared across the project.
-     */
-    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;
-}
+/** @deprecated Use MutationParams instead */
+declare 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>;
 export { BaseMutationParams }
 export { BaseMutationParams as BaseMutationParams_alias_1 }
+export { BaseMutationParams as BaseMutationParams_alias_2 }
 
+/** @deprecated Use QueryArgs instead */
 declare type BaseQueryArgs<Config extends AnyEndpointConfig> = (UrlHasParams<Config['url']> extends true ? {
     urlParams: UrlParams<Config['url']>;
 } : {}) & (Config['querySchema'] extends ZodObject ? {
@@ -57,58 +48,53 @@ declare type BaseQueryArgs<Config extends AnyEndpointConfig> = (UrlHasParams<Con
 } : {});
 export { BaseQueryArgs }
 export { BaseQueryArgs as BaseQueryArgs_alias_1 }
+export { BaseQueryArgs as BaseQueryArgs_alias_2 }
 
-declare type BaseQueryParams<Config extends AnyEndpointConfig, Res = any> = {
-    keyPrefix?: string[];
-    keySuffix?: string[];
-    onFail?: (err: unknown) => void;
-    processResponse: (data: z.output<Config['responseSchema']>) => Res;
-};
+/** @deprecated Use QueryParams instead */
+declare type BaseQueryParams<Config extends AnyEndpointConfig, Res = unknown> = QueryParams<Config, Res>;
 export { BaseQueryParams }
 export { BaseQueryParams as BaseQueryParams_alias_1 }
+export { BaseQueryParams as BaseQueryParams_alias_2 }
 
-declare interface ClientEndpointDefinition<Method = HttpMethod, Url = string, QuerySchema = unknown, Response = ZodType> {
-    method: Method;
-    url: Url;
-    querySchema?: QuerySchema;
-    responseSchema: Response;
-}
-export { ClientEndpointDefinition }
-export { ClientEndpointDefinition as ClientEndpointDefinition_alias_1 }
-
-declare type ClientEndpointHelper<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>;
-    };
-};
+/** @deprecated Use EndpointHelper instead */
+declare 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>;
 export { ClientEndpointHelper }
 export { ClientEndpointHelper as ClientEndpointHelper_alias_1 }
 export { ClientEndpointHelper as ClientEndpointHelper_alias_2 }
 
-declare type ClientInfiniteQueryConfig<Method = HttpMethod, Url = string, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, PageResult = z.output<Response>, Result = InfiniteData<PageResult>> = Required<ClientEndpointDefinition<Method, Url, QuerySchema, Response>> & {
-    processResponse?: (data: z.output<Response>) => PageResult;
-    select?: (data: InfiniteData<PageResult>) => Result;
-    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>;
-    initialPageParam?: z.input<QuerySchema>;
-};
-export { ClientInfiniteQueryConfig }
-export { ClientInfiniteQueryConfig as ClientInfiniteQueryConfig_alias_1 }
-
+/**
+ * The main client instance interface.
+ * Provides methods for creating queries, infinite queries, and mutations.
+ */
 declare interface ClientInstance {
     query<Method extends 'GET' | 'HEAD' | 'OPTIONS' = 'GET', Url extends string = string, Response extends ZodType = ZodType, Result = z.output<Response>>(config: {
         method: Method;
         url: Url;
         responseSchema: Response;
         processResponse?: (data: z.output<Response>) => Result;
-    }): ((params: Util_FlatObject<ClientQueryArgs<Url, undefined>>) => UseSuspenseQueryOptions<Result, Error, Result, DataTag<Split<Url, '/'>, Result, Error>>) & QueryHelpers<Url, undefined, Result> & ClientEndpointHelper<Method, Url, undefined, Response>;
+    }): ((params: Util_FlatObject<QueryArgs<Url, undefined>>) => UseSuspenseQueryOptions<Result, Error, Result, DataTag<Split<Url, '/'>, Result, Error>>) & QueryHelpers<Url, undefined, Result> & 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 = z.output<Response>>(config: {
         method: Method;
         url: Url;
         querySchema: QuerySchema;
         responseSchema: Response;
         processResponse?: (data: z.output<Response>) => Result;
-    }): ((params: Util_FlatObject<ClientQueryArgs<Url, QuerySchema>>) => UseSuspenseQueryOptions<Result, Error, Result, DataTag<Split<Url, '/'>, Result, Error>>) & QueryHelpers<Url, QuerySchema, Result> & ClientEndpointHelper<Method, Url, undefined, Response, QuerySchema>;
+    }): ((params: Util_FlatObject<QueryArgs<Url, QuerySchema>>) => UseSuspenseQueryOptions<Result, Error, Result, DataTag<Split<Url, '/'>, Result, Error>>) & QueryHelpers<Url, QuerySchema, Result> & EndpointHelper<Method, Url, undefined, Response, QuerySchema>;
+    query<Method extends 'POST' = 'POST', Url extends string = string, RequestSchema extends ZodType = ZodType, Response extends ZodType = ZodType, Result = z.output<Response>>(config: {
+        method: Method;
+        url: Url;
+        requestSchema: RequestSchema;
+        responseSchema: Response;
+        processResponse?: (data: z.output<Response>) => Result;
+    }): ((params: Util_FlatObject<QueryArgs<Url, undefined, RequestSchema>>) => UseSuspenseQueryOptions<Result, Error, Result, DataTag<Split<Url, '/'>, Result, Error>>) & QueryHelpers<Url, undefined, Result, 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 = z.output<Response>>(config: {
+        method: Method;
+        url: Url;
+        querySchema: QuerySchema;
+        requestSchema: RequestSchema;
+        responseSchema: Response;
+        processResponse?: (data: z.output<Response>) => Result;
+    }): ((params: Util_FlatObject<QueryArgs<Url, QuerySchema, RequestSchema>>) => UseSuspenseQueryOptions<Result, Error, Result, DataTag<Split<Url, '/'>, Result, Error>>) & QueryHelpers<Url, QuerySchema, Result, 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 = InfiniteData<PageResult>>(config: {
         method: Method;
         url: Url;
@@ -117,7 +103,17 @@ declare interface ClientInstance {
         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<ClientQueryArgs<Url, QuerySchema>>) => UseSuspenseInfiniteQueryOptions<PageResult, Error, Result, DataTag<Split<Url, '/'>, PageResult, Error>, z.output<QuerySchema>>) & QueryHelpers<Url, QuerySchema, PageResult, true> & ClientEndpointHelper<Method, Url, undefined, Response, QuerySchema>;
+    }): ((params: Util_FlatObject<QueryArgs<Url, QuerySchema>>) => UseSuspenseInfiniteQueryOptions<PageResult, Error, Result, 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 = 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, 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 = unknown, Context = unknown, UseKey extends true = true>(config: {
         method: Method;
         url: Url;
@@ -127,11 +123,11 @@ declare interface ClientInstance {
         responseSchema: Response;
         processResponse: ProcessResponseFunction<Result, ReqResult>;
         useContext?: () => Context;
-        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<ClientMutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
-        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<ClientMutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
     }): ((params: UrlHasParams<Url> extends true ? {
         urlParams: UrlParams<Url>;
-    } : {}) => UseMutationResult<Result, Error, ClientMutationArgs<Url, RequestSchema, QuerySchema>>) & MutationHelpers<Url, Result> & ClientEndpointHelper<Method, Url, RequestSchema, Response, QuerySchema>;
+    } : {}) => UseMutationResult<Result, Error, MutationArgs<Url, RequestSchema, QuerySchema>>) & MutationHelpers<Url, Result> & 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 = unknown, Context = unknown>(config: {
         method: Method;
         url: Url;
@@ -140,9 +136,9 @@ declare interface ClientInstance {
         responseSchema: Response;
         processResponse: ProcessResponseFunction<Result, ReqResult>;
         useContext?: () => Context;
-        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<ClientMutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
-        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<ClientMutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
-    }): (() => UseMutationResult<Result, Error, ClientMutationArgs<Url, RequestSchema, QuerySchema>>) & ClientEndpointHelper<Method, Url, RequestSchema, Response, QuerySchema>;
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
+    }): (() => UseMutationResult<Result, Error, MutationArgs<Url, RequestSchema, QuerySchema>>) & MutationHelpers<Url, Result> & 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 = unknown, Context = unknown>(config: {
         method: Method;
         url: Url;
@@ -150,9 +146,9 @@ declare interface ClientInstance {
         responseSchema: Response;
         processResponse: ProcessResponseFunction<Result, ReqResult>;
         useContext?: () => Context;
-        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<ClientMutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
-        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<ClientMutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
-    }): (() => UseMutationResult<Result, Error, ClientMutationArgs<Url, RequestSchema, undefined>>) & MutationHelpers<Url, Result> & ClientEndpointHelper<Method, Url, RequestSchema, Response>;
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
+    }): (() => UseMutationResult<Result, Error, MutationArgs<Url, RequestSchema, undefined>>) & MutationHelpers<Url, Result> & 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 = unknown, Context = unknown, UseKey extends true = true>(config: {
         method: Method;
         url: Url;
@@ -161,9 +157,9 @@ declare interface ClientInstance {
         responseSchema: Response;
         processResponse: ProcessResponseFunction<Result, ReqResult>;
         useContext?: () => Context;
-        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<ClientMutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
-        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<ClientMutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
-    }): ((params: UrlHasParams<Url> extends true ? UrlParams<Url> : {}) => UseMutationResult<Result, Error, ClientMutationArgs<Url, RequestSchema, undefined>>) & MutationHelpers<Url, Result> & ClientEndpointHelper<Method, Url, RequestSchema, Response>;
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
+    }): ((params: UrlHasParams<Url> extends true ? UrlParams<Url> : {}) => UseMutationResult<Result, Error, MutationArgs<Url, RequestSchema, undefined>>) & MutationHelpers<Url, Result> & 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 = unknown, Context = unknown, UseKey extends true = true>(config: {
         method: Method;
         url: Url;
@@ -172,9 +168,9 @@ declare interface ClientInstance {
         responseSchema: Response;
         processResponse: ProcessResponseFunction<Result, ReqResult>;
         useContext?: () => Context;
-        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<ClientMutationArgs<Url, undefined, QuerySchema>>, context: Context) => void | Promise<void>;
-        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<ClientMutationArgs<Url, undefined, QuerySchema>>, context: Context) => void | Promise<void>;
-    }): ((params: UrlHasParams<Url> extends true ? UrlParams<Url> : {}) => UseMutationResult<Result, Error, ClientMutationArgs<Url, undefined, QuerySchema>>) & MutationHelpers<Url, Result> & ClientEndpointHelper<Method, Url, undefined, Response, QuerySchema>;
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context) => void | Promise<void>;
+    }): ((params: UrlHasParams<Url> extends true ? UrlParams<Url> : {}) => UseMutationResult<Result, Error, MutationArgs<Url, undefined, QuerySchema>>) & MutationHelpers<Url, Result> & 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 = unknown, Context = unknown>(config: {
         method: Method;
         url: Url;
@@ -182,9 +178,9 @@ declare interface ClientInstance {
         responseSchema: Response;
         processResponse: ProcessResponseFunction<Result, ReqResult>;
         useContext?: () => Context;
-        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<ClientMutationArgs<Url, undefined, QuerySchema>>, context: Context) => void | Promise<void>;
-        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<ClientMutationArgs<Url, undefined, QuerySchema>>, context: Context) => void | Promise<void>;
-    }): (() => UseMutationResult<Result, Error, ClientMutationArgs<Url, undefined, QuerySchema>>) & ClientEndpointHelper<Method, Url, undefined, Response, QuerySchema>;
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context) => void | Promise<void>;
+    }): (() => UseMutationResult<Result, Error, MutationArgs<Url, undefined, QuerySchema>>) & MutationHelpers<Url, Result> & EndpointHelper<Method, Url, undefined, Response, QuerySchema>;
     mutation<Method extends 'DELETE' = 'DELETE', Url extends string = string, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result = unknown, Context = unknown, UseKey extends true = true>(config: {
         method: Method;
         url: Url;
@@ -192,137 +188,164 @@ declare interface ClientInstance {
         responseSchema: Response;
         processResponse: ProcessResponseFunction<Result, ReqResult>;
         useContext?: () => Context;
-        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<ClientMutationArgs<Url, undefined, undefined>>, context: Context) => void | Promise<void>;
-        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<ClientMutationArgs<Url, undefined, undefined>>, context: Context) => void | Promise<void>;
-    }): ((params: UrlHasParams<Url> extends true ? UrlParams<Url> : {}) => UseMutationResult<Result, Error, ClientMutationArgs<Url, undefined, undefined>>) & MutationHelpers<Url, Result> & ClientEndpointHelper<Method, Url, undefined, Response>;
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context) => void | Promise<void>;
+    }): ((params: UrlHasParams<Url> extends true ? UrlParams<Url> : {}) => UseMutationResult<Result, Error, MutationArgs<Url, undefined, undefined>>) & MutationHelpers<Url, Result> & EndpointHelper<Method, Url, undefined, Response>;
     mutation<Method extends 'DELETE' = 'DELETE', Url extends string = string, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result = unknown, Context = unknown>(config: {
         method: Method;
         url: Url;
         responseSchema: Response;
         processResponse: ProcessResponseFunction<Result, ReqResult>;
         useContext?: () => Context;
-        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<ClientMutationArgs<Url, undefined, undefined>>, context: Context) => void | Promise<void>;
-        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<ClientMutationArgs<Url, undefined, undefined>>, context: Context) => void | Promise<void>;
-    }): (() => UseMutationResult<Result, Error, ClientMutationArgs<Url, undefined, undefined>>) & ClientEndpointHelper<Method, Url, undefined, Response>;
-    queryFromEndpoint<Method extends 'GET' | 'HEAD' | 'OPTIONS' = 'GET', Url extends string = string, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, Result = z.output<Response>>(endpoint: any & {
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context) => void | Promise<void>;
+    }): (() => UseMutationResult<Result, Error, MutationArgs<Url, undefined, undefined>>) & MutationHelpers<Url, Result> & 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 = z.output<Response>>(endpoint: {
         config: BaseEndpointConfig<Method, Url, QuerySchema, Response>;
     }, options?: {
         processResponse?: (data: z.output<Response>) => Result;
-    }): (params: UrlHasParams<Url> extends true ? {
-        urlParams: UrlParams<Url>;
-    } : {}) => UseSuspenseQueryOptions<Result, Error, Result, DataTag<Split<Url, '/'>, Result, Error>> & QueryHelpers<Url, QuerySchema, Result>;
-    queryFromEndpoint<Method extends 'GET' | 'HEAD' | 'OPTIONS' = 'GET', Url extends string = string, Response extends ZodType = ZodType, Result = z.output<Response>>(endpoint: any & {
+    }): (params: Util_FlatObject<QueryArgs<Url, QuerySchema>>) => UseSuspenseQueryOptions<Result, Error, Result, DataTag<Split<Url, '/'>, Result, Error>> & QueryHelpers<Url, QuerySchema, Result>;
+    queryFromEndpoint<Method extends 'GET' | 'HEAD' | 'OPTIONS' = 'GET', Url extends string = string, Response extends ZodType = ZodType, Result = z.output<Response>>(endpoint: {
         config: BaseEndpointConfig<Method, Url, undefined, Response>;
     }, options?: {
         processResponse?: (data: z.output<Response>) => Result;
-    }): ((params: UrlHasParams<Url> extends true ? {
-        urlParams: UrlParams<Url>;
-    } : {}) => UseSuspenseQueryOptions<Result, Error, Result, DataTag<Split<Url, '/'>, Result, Error>>) & QueryHelpers<Url, undefined, Result>;
-    infiniteQueryFromEndpoint<Method extends 'GET' | 'HEAD' | 'OPTIONS' = 'GET', Url extends string = string, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, PageResult = z.output<Response>, Result = InfiniteData<PageResult>>(endpoint: any & {
+    }): ((params: Util_FlatObject<QueryArgs<Url, undefined>>) => UseSuspenseQueryOptions<Result, Error, Result, DataTag<Split<Url, '/'>, Result, Error>>) & QueryHelpers<Url, undefined, Result>;
+    infiniteQueryFromEndpoint<Method extends 'GET' | 'HEAD' | 'OPTIONS' = 'GET', Url extends string = string, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, PageResult = z.output<Response>, Result = InfiniteData<PageResult>>(endpoint: {
         config: BaseEndpointConfig<Method, Url, QuerySchema, Response>;
     }, 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: UrlHasParams<Url> extends true ? {
-        urlParams: UrlParams<Url>;
-    } : {}) => UseSuspenseInfiniteQueryOptions<PageResult, Error, Result, 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 = unknown, Context = unknown, UseKey extends true = true>(endpoint: any & {
+    }): ((params: Util_FlatObject<QueryArgs<Url, QuerySchema>>) => UseSuspenseInfiniteQueryOptions<PageResult, Error, Result, 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 = unknown, Context = unknown, UseKey extends true = true>(endpoint: {
         config: BaseEndpointConfig<Method, Url, QuerySchema, Response, RequestSchema>;
     }, mutationOptions: {
         processResponse: ProcessResponseFunction<Result, ReqResult>;
         useKey: UseKey;
         useContext?: () => Context;
-        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<ClientMutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
-        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<ClientMutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
-    }): ((params: UrlHasParams<Url> extends true ? UrlParams<Url> : {}) => UseMutationResult<Result, Error, ClientMutationArgs<Url, RequestSchema, QuerySchema>>) & MutationHelpers<Url, Result> & ClientEndpointHelper<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 = unknown, Context = unknown, UseKey extends true = true>(endpoint: any & {
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
+    }): ((params: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>) => UseMutationResult<Result, Error, MutationArgs<Url, RequestSchema, QuerySchema>>) & MutationHelpers<Url, Result> & 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 = unknown, Context = unknown, UseKey extends true = true>(endpoint: {
         config: BaseEndpointConfig<Method, Url, undefined, Response, RequestSchema>;
     }, mutationOptions: {
         processResponse: ProcessResponseFunction<Result, ReqResult>;
         useKey: UseKey;
         useContext?: () => Context;
-        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<ClientMutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
-        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<ClientMutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
-    }): ((params: UrlHasParams<Url> extends true ? UrlParams<Url> : {}) => UseMutationResult<Result, Error, ClientMutationArgs<Url, RequestSchema, undefined>>) & MutationHelpers<Url, Result> & ClientEndpointHelper<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 = unknown, Context = unknown>(endpoint: any & {
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
+    }): ((params: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>) => UseMutationResult<Result, Error, MutationArgs<Url, RequestSchema, undefined>>) & MutationHelpers<Url, Result> & 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 = unknown, Context = unknown>(endpoint: {
         config: BaseEndpointConfig<Method, Url, QuerySchema, Response, RequestSchema>;
     }, mutationOptions: {
         processResponse: ProcessResponseFunction<Result, ReqResult>;
         useContext?: () => Context;
-        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<ClientMutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
-        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<ClientMutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
-    }): (() => UseMutationResult<Result, Error, ClientMutationArgs<Url, RequestSchema, QuerySchema>>) & ClientEndpointHelper<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 = unknown, Context = unknown>(endpoint: any & {
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
+    }): ((params: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>) => UseMutationResult<Result, Error, MutationArgs<Url, RequestSchema, QuerySchema>>) & 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 = unknown, Context = unknown>(endpoint: {
         config: BaseEndpointConfig<Method, Url, undefined, Response, RequestSchema>;
     }, mutationOptions: {
         processResponse: ProcessResponseFunction<Result, ReqResult>;
         useContext?: () => Context;
-        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<ClientMutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
-        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<ClientMutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
-    }): (() => UseMutationResult<Result, Error, ClientMutationArgs<Url, RequestSchema, undefined>>) & ClientEndpointHelper<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 = unknown, Context = unknown, UseKey extends true = true>(endpoint: any & {
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
+    }): ((params: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>) => UseMutationResult<Result, Error, MutationArgs<Url, RequestSchema, undefined>>) & 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 = unknown, Context = unknown, UseKey extends true = true>(endpoint: {
         config: BaseEndpointConfig<Method, Url, QuerySchema, Response>;
     }, mutationOptions: {
         processResponse: ProcessResponseFunction<Result, ReqResult>;
         useKey: UseKey;
         useContext?: () => Context;
-        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<ClientMutationArgs<Url, undefined, QuerySchema>>, context: Context) => void | Promise<void>;
-        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<ClientMutationArgs<Url, undefined, QuerySchema>>, context: Context) => void | Promise<void>;
-    }): ((params: UrlHasParams<Url> extends true ? UrlParams<Url> : {}) => UseMutationResult<Result, Error, ClientMutationArgs<Url, undefined, QuerySchema>>) & MutationHelpers<Url, Result> & ClientEndpointHelper<Method, Url, undefined, Response, QuerySchema>;
-    mutationFromEndpoint<Method extends 'DELETE' = 'DELETE', Url extends string = string, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result = unknown, Context = unknown, UseKey extends true = true>(endpoint: any & {
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context) => void | Promise<void>;
+    }): ((params: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>) => UseMutationResult<Result, Error, MutationArgs<Url, undefined, QuerySchema>>) & MutationHelpers<Url, Result> & EndpointHelper<Method, Url, undefined, Response, QuerySchema>;
+    mutationFromEndpoint<Method extends 'DELETE' = 'DELETE', Url extends string = string, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result = unknown, Context = unknown, UseKey extends true = true>(endpoint: {
         config: BaseEndpointConfig<Method, Url, undefined, Response>;
     }, mutationOptions: {
         processResponse: ProcessResponseFunction<Result, ReqResult>;
         useKey: UseKey;
         useContext?: () => Context;
-        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<ClientMutationArgs<Url, undefined, undefined>>, context: Context) => void | Promise<void>;
-        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<ClientMutationArgs<Url, undefined, undefined>>, context: Context) => void | Promise<void>;
-    }): ((params: UrlHasParams<Url> extends true ? UrlParams<Url> : {}) => UseMutationResult<Result, Error, ClientMutationArgs<Url, undefined, undefined>>) & MutationHelpers<Url, Result> & ClientEndpointHelper<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 = unknown, Context = unknown>(endpoint: any & {
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context) => void | Promise<void>;
+    }): ((params: Util_FlatObject<MutationArgs<Url, undefined, undefined>>) => UseMutationResult<Result, Error, MutationArgs<Url, undefined, undefined>>) & MutationHelpers<Url, Result> & 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 = unknown, Context = unknown>(endpoint: {
         config: BaseEndpointConfig<Method, Url, QuerySchema, Response>;
     }, mutationOptions: {
         processResponse: ProcessResponseFunction<Result, ReqResult>;
         useContext?: () => Context;
-        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<ClientMutationArgs<Url, undefined, QuerySchema>>, context: Context) => void | Promise<void>;
-        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<ClientMutationArgs<Url, undefined, QuerySchema>>, context: Context) => void | Promise<void>;
-    }): (() => UseMutationResult<Result, Error, ClientMutationArgs<Url, undefined, QuerySchema>>) & ClientEndpointHelper<Method, Url, undefined, Response, QuerySchema>;
-    mutationFromEndpoint<Method extends 'DELETE' = 'DELETE', Url extends string = string, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result = unknown, Context = unknown>(endpoint: any & {
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>, context: Context) => void | Promise<void>;
+    }): ((params: Util_FlatObject<MutationArgs<Url, undefined, QuerySchema>>) => UseMutationResult<Result, Error, MutationArgs<Url, undefined, QuerySchema>>) & EndpointHelper<Method, Url, undefined, Response, QuerySchema>;
+    mutationFromEndpoint<Method extends 'DELETE' = 'DELETE', Url extends string = string, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result = unknown, Context = unknown>(endpoint: {
         config: BaseEndpointConfig<Method, Url, undefined, Response>;
     }, mutationOptions: {
         processResponse: ProcessResponseFunction<Result, ReqResult>;
         useContext?: () => Context;
-        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<ClientMutationArgs<Url, undefined, undefined>>, context: Context) => void | Promise<void>;
-        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<ClientMutationArgs<Url, undefined, undefined>>, context: Context) => void | Promise<void>;
-    }): ((params: UrlHasParams<Url> extends true ? UrlParams<Url> : {}) => UseMutationResult<Result, Error, ClientMutationArgs<Url, undefined, undefined>>) & ClientEndpointHelper<Method, Url, undefined, Response, undefined>;
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, undefined, undefined>>, context: Context) => void | Promise<void>;
+    }): ((params: Util_FlatObject<MutationArgs<Url, undefined, undefined>>) => UseMutationResult<Result, Error, MutationArgs<Url, undefined, undefined>>) & 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 = unknown, Context = unknown, UseKey extends true = true>(config: {
+        method: Method;
+        url: Url;
+        useKey: UseKey;
+        requestSchema: RequestSchema;
+        querySchema: QuerySchema;
+        responseSchema: Response;
+        processResponse: ProcessResponseFunction<Result, ReqResult>;
+        useContext?: () => Context;
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
+    }): ((params: UrlHasParams<Url> extends true ? {
+        urlParams: UrlParams<Url>;
+    } : {}) => UseMutationResult<Result, Error, MutationArgs<Url, RequestSchema, QuerySchema>>) & MutationHelpers<Url, Result> & 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 = unknown, Context = unknown>(config: {
+        method: Method;
+        url: Url;
+        requestSchema: RequestSchema;
+        querySchema: QuerySchema;
+        responseSchema: Response;
+        processResponse: ProcessResponseFunction<Result, ReqResult>;
+        useContext?: () => Context;
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
+    }): (() => UseMutationResult<Result, Error, MutationArgs<Url, RequestSchema, QuerySchema>>) & MutationHelpers<Url, Result> & 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 = unknown, Context = unknown>(config: {
+        method: Method;
+        url: Url;
+        requestSchema: RequestSchema;
+        responseSchema: Response;
+        processResponse: ProcessResponseFunction<Result, ReqResult>;
+        useContext?: () => Context;
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
+    }): (() => UseMutationResult<Result, Error, MutationArgs<Url, RequestSchema, undefined>>) & MutationHelpers<Url, Result> & 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 = unknown, Context = unknown, UseKey extends true = true>(config: {
+        method: Method;
+        url: Url;
+        useKey: UseKey;
+        requestSchema: RequestSchema;
+        responseSchema: Response;
+        processResponse: ProcessResponseFunction<Result, ReqResult>;
+        useContext?: () => Context;
+        onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
+        onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<MutationArgs<Url, RequestSchema, undefined>>, context: Context) => void | Promise<void>;
+    }): ((params: UrlHasParams<Url> extends true ? UrlParams<Url> : {}) => UseMutationResult<Result, Error, MutationArgs<Url, RequestSchema, undefined>>) & MutationHelpers<Url, Result> & EndpointHelper<Method, Url, RequestSchema, Response>;
 }
 export { ClientInstance }
 export { ClientInstance as ClientInstance_alias_1 }
 export { ClientInstance as ClientInstance_alias_2 }
 
-declare type ClientMutationArgs<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>;
-} : {});
+/** @deprecated Use MutationArgs instead */
+declare type ClientMutationArgs<Url extends string = string, RequestSchema = unknown, QuerySchema = unknown> = MutationArgs<Url, RequestSchema, QuerySchema>;
 export { ClientMutationArgs }
 export { ClientMutationArgs as ClientMutationArgs_alias_1 }
 export { ClientMutationArgs as ClientMutationArgs_alias_2 }
 
-declare interface ClientMutationDataConfig<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 = unknown, Context = unknown, UseKey extends boolean = false> extends ClientEndpointDefinition<Method, Url, QuerySchema, Response> {
-    requestSchema?: RequestSchema;
-    processResponse: ProcessResponseFunction<Result, ReqResult>;
-    useContext?: () => Context;
-    onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: Util_FlatObject<ClientMutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
-    onError?: (queryClient: QueryClient, error: Error, variables: Util_FlatObject<ClientMutationArgs<Url, RequestSchema, QuerySchema>>, context: Context) => void | Promise<void>;
-    useKey?: UseKey;
-}
-export { ClientMutationDataConfig }
-export { ClientMutationDataConfig as ClientMutationDataConfig_alias_1 }
-
-declare type ClientOptions<ProcessResponse = unknown> = {
+/**
+ * Options for creating a client instance.
+ */
+declare type ClientOptions = {
     api: BuilderInstance;
     defaults?: {
         keyPrefix?: string[];
@@ -331,79 +354,249 @@ declare type ClientOptions<ProcessResponse = unknown> = {
 };
 export { ClientOptions }
 export { ClientOptions as ClientOptions_alias_1 }
+export { ClientOptions as ClientOptions_alias_2 }
 
-declare type ClientQueryArgs<Url extends string = string, QuerySchema = ZodObject> = (UrlHasParams<Url> extends true ? {
-    urlParams: UrlParams<Url>;
-} : {}) & (QuerySchema extends ZodObject ? {
-    params: z.input<QuerySchema>;
-} : {});
+/** @deprecated Use QueryArgs instead */
+declare type ClientQueryArgs<Url extends string = string, QuerySchema = ZodObject, RequestSchema = undefined> = QueryArgs<Url, QuerySchema, RequestSchema>;
 export { ClientQueryArgs }
 export { ClientQueryArgs as ClientQueryArgs_alias_1 }
 export { ClientQueryArgs as ClientQueryArgs_alias_2 }
 
-declare interface ClientQueryConfig<Method = HttpMethod, Url = string, QuerySchema = ZodObject, Response extends ZodType = ZodType, Result = z.output<Response>> extends ClientEndpointDefinition<Method, Url, QuerySchema, Response> {
-    processResponse?: (data: z.output<Response>) => Result;
-}
-export { ClientQueryConfig }
-export { ClientQueryConfig as ClientQueryConfig_alias_1 }
-
-declare type ClientQueryUrlParamsArgs<Url extends string = string> = UrlHasParams<Url> extends true ? {
-    urlParams: UrlParams<Url>;
-} : {} | undefined;
+/** @deprecated Use QueryUrlParamsArgs instead */
+declare type ClientQueryUrlParamsArgs<Url extends string = string> = QueryUrlParamsArgs<Url>;
 export { ClientQueryUrlParamsArgs }
 export { ClientQueryUrlParamsArgs as ClientQueryUrlParamsArgs_alias_1 }
 export { ClientQueryUrlParamsArgs as ClientQueryUrlParamsArgs_alias_2 }
 
+/**
+ * Creates a mutation key generator for a given endpoint configuration.
+ *
+ * @param config - The endpoint configuration
+ * @param options - Optional query parameters with a default `processResponse` function
+ * @returns A function that generates mutation keys
+ *
+ * @example Basic usage:
+ * ```typescript
+ * const createMutationKey = createMutationKey(endpoint.config);
+ * const mutationKey = createMutationKey({ urlParams: { id: 123 } });
+ * ```
+ *
+ * @example Advanced usage with processResponse:
+ * ```ts
+ * const createMutationKey = createMutationKey(endpoint.config, {
+ *   processResponse: (data) => {
+ *     if (!data.success) {
+ *       throw new Error(data.message);
+ *     }
+ *     return data.data;
+ *   },
+ * });
+ * // We create a mutation that will be shared across the project for all passed userId
+ * const mutationKey = createMutationKey({ urlParams: { projectId: 123, userId: 'wildcard' } });
+ * ```
+ */
+declare function createMutationKey<Config extends AnyEndpointConfig, Options extends QueryParams<Config>, Url extends Config['url'] = Config['url'], HasParams extends UrlHasParams<Url> = UrlHasParams<Url>>(config: Config, options?: Options): (params: HasParams extends true ? {
+    urlParams: UrlParams<Url>;
+} : {}) => Options['processResponse'] extends (...args: unknown[]) => infer Result ? DataTag<[Config['url']], Result, Error> : never;
+export { createMutationKey }
+export { createMutationKey as createMutationKey_alias_1 }
+export { createMutationKey as createMutationKey_alias_2 }
+
+/**
+ * Creates a query key generator for a given endpoint configuration.
+ *
+ * The returned object provides methods to generate query keys that can be used
+ * with TanStack Query for caching, invalidation, and data tagging.
+ *
+ * @param config - The endpoint configuration
+ * @param options - Query parameters including processResponse and key prefix/suffix
+ * @param isInfinite - Whether this is for an infinite query
+ * @returns An object with methods to generate query keys
+ */
+declare function createQueryKey<Config extends AnyEndpointConfig, Options extends QueryParams<Config>, IsInfinite extends boolean, Url extends Config['url'] = Config['url'], HasParams extends UrlHasParams<Url> = UrlHasParams<Url>>(config: Config, options: Options, _isInfinite: IsInfinite): QueryKeyCreatorResult<Config['querySchema'], Url, Options['processResponse'] extends (...args: any[]) => infer Result ? Result : never, IsInfinite, HasParams>;
+export { createQueryKey }
+export { createQueryKey as createQueryKey_alias_1 }
+export { createQueryKey as createQueryKey_alias_2 }
+
+/**
+ * Creates a client instance for making type-safe queries and mutations.
+ *
+ * @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 client = declareClient({ api });
+ *
+ * const getUser = client.query({
+ *   method: 'GET',
+ *   url: '/users/$id',
+ *   responseSchema: UserSchema,
+ * });
+ *
+ * // In a component
+ * const { data } = useSuspenseQuery(getUser({ urlParams: { id: '123' } }));
+ * ```
+ */
 declare function declareClient<Options extends ClientOptions>({ api, defaults, }: Options): ClientInstance;
 export { declareClient }
 export { declareClient as declareClient_alias_1 }
+export { declareClient as declareClient_alias_2 }
+
+/**
+ * Helper type that attaches the endpoint to query/mutation results.
+ */
+declare 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>;
+    };
+};
+export { EndpointHelper }
+export { EndpointHelper as EndpointHelper_alias_1 }
+export { EndpointHelper as EndpointHelper_alias_2 }
 
+/**
+ * Configuration for declaring an infinite query endpoint.
+ */
+declare type InfiniteQueryConfig<Method = HttpMethod, Url = string, QuerySchema extends ZodObject = ZodObject, Response extends ZodType = ZodType, PageResult = z.output<Response>, Result = InfiniteData<PageResult>, RequestSchema = unknown> = {
+    method: Method;
+    url: Url;
+    querySchema: QuerySchema;
+    responseSchema: Response;
+    requestSchema?: RequestSchema;
+    processResponse?: (data: z.output<Response>) => PageResult;
+    select?: (data: InfiniteData<PageResult>) => Result;
+    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>;
+    initialPageParam?: z.input<QuerySchema>;
+};
+export { InfiniteQueryConfig }
+export { InfiniteQueryConfig as InfiniteQueryConfig_alias_1 }
+export { InfiniteQueryConfig as InfiniteQueryConfig_alias_2 }
+
+/**
+ * Options for infinite query configuration.
+ */
 declare type InfiniteQueryOptions<Config extends BaseEndpointConfig<HttpMethod, string, ZodObject>, Res = any> = {
     keyPrefix?: string[];
     keySuffix?: string[];
     processResponse: (data: z.infer<Config['responseSchema']>) => 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']>;
 };
 export { InfiniteQueryOptions }
 export { InfiniteQueryOptions as InfiniteQueryOptions_alias_1 }
+export { InfiniteQueryOptions as InfiniteQueryOptions_alias_2 }
 
+/**
+ * Creates infinite query options for a given endpoint.
+ *
+ * Returns a function that generates TanStack Query infinite options when called with params.
+ * The returned function also has helper methods attached (use, useSuspense, invalidate, etc.)
+ *
+ * @param endpoint - The navios endpoint to create infinite query options for
+ * @param options - Infinite query configuration including processResponse and pagination params
+ * @param baseQuery - Optional base query options to merge
+ * @returns A function that generates infinite query options with attached helpers
+ */
 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: ClientQueryArgs): Options["processResponse"] extends (...args: any[]) => infer Result ? UseSuspenseInfiniteQueryOptions<Result, Error, BaseQuery["select"] extends (...args: any[]) => infer T ? T : InfiniteData<Result>> : never;
+    (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;
     queryKey: QueryKeyCreatorResult_2<Config["querySchema"], Config["url"], Options["processResponse"] extends (...args: any[]) => infer Result ? Result : never, true, UrlHasParams<Config["url"]>>;
-    use(params: ClientQueryArgs): UseInfiniteQueryResult<BaseQuery["select"] extends (...args: any[]) => infer T ? T : InfiniteData<unknown, unknown>, Error>;
-    useSuspense(params: ClientQueryArgs): UseSuspenseInfiniteQueryResult<BaseQuery["select"] extends (...args: any[]) => infer T ? T : InfiniteData<unknown, unknown>, Error>;
-    invalidate(queryClient: QueryClient, params: ClientQueryArgs): Promise<void>;
-    invalidateAll(queryClient: QueryClient, params: ClientQueryArgs): Promise<void>;
+    use(params: QueryArgs<Config["url"], Config["querySchema"]>): UseInfiniteQueryResult<BaseQuery["select"] extends (...args: any[]) => infer T ? T : InfiniteData<unknown, unknown>, Error>;
+    useSuspense(params: QueryArgs<Config["url"], Config["querySchema"]>): 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>;
 };
 export { makeInfiniteQueryOptions }
 export { makeInfiniteQueryOptions as makeInfiniteQueryOptions_alias_1 }
+export { makeInfiniteQueryOptions as makeInfiniteQueryOptions_alias_2 }
 
-declare function makeMutation<Config extends AnyEndpointConfig, TData = unknown, TVariables extends BaseMutationArgs<Config> = BaseMutationArgs<Config>, TResponse = z.output<Config['responseSchema']>, TContext = unknown, UseKey extends boolean = false>(endpoint: AbstractEndpoint<Config>, options: BaseMutationParams<Config, TData, TVariables, TResponse, TContext, UseKey>): {
-    (keyParams: UseKey extends true ? UrlHasParams<Config["url"]> extends true ? UrlParams<Config["url"]> : never : never): UseMutationResult<TData, Error, BaseMutationArgs<Config>>;
+/**
+ * Creates a mutation hook for a given endpoint.
+ *
+ * Returns a function that when called returns a TanStack Query mutation result.
+ * The returned function also has helper methods attached (mutationKey, useIsMutating).
+ *
+ * @param endpoint - The navios endpoint to create a mutation hook for
+ * @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']>, TContext = unknown, UseKey extends boolean = false>(endpoint: AbstractEndpoint<Config>, options: MutationParams<Config, TData, TVariables, TResponse, TContext, UseKey>): {
+    (keyParams: UseKey extends true ? UrlHasParams<Config["url"]> extends true ? UrlParams<Config["url"]> : never : never): UseMutationResult<TData, Error, NaviosZodRequest<Config>>;
     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) => [Config["url"]] & {
-        [dataTagSymbol]: TData | Promise<TData>;
+    } : {} : never : never) => ProcessResponseFunction_2<TData, TResponse> extends (...args: unknown[]) => infer Result ? [Config["url"]] & {
+        [dataTagSymbol]: Result;
         [dataTagErrorSymbol]: Error;
-    };
+    } : never;
 };
 export { makeMutation }
 export { makeMutation as makeMutation_alias_1 }
+export { makeMutation as makeMutation_alias_2 }
 
-declare function makeQueryOptions<Config extends AnyEndpointConfig, Options extends BaseQueryParams<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: BaseQueryArgs<Config>): Options["processResponse"] extends (...args: any[]) => infer Result ? UseSuspenseQueryOptions<Result, Error, BaseQuery["select"] extends (...args: any[]) => infer T ? T : Result, DataTag<Split_3<Config["url"], "/">, Result, Error>> : never;
+/**
+ * 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
+ * @param options - Query configuration including processResponse
+ * @param baseQuery - Optional base query options to merge
+ * @returns A function that generates query options with attached helpers
+ */
+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_2<Config["querySchema"], Config["url"], Options["processResponse"] extends (...args: any[]) => infer Result ? Result : never, false, UrlHasParams<Config["url"]>>;
-    use(params: ClientQueryArgs): UseQueryResult<NoInfer_2<BaseQuery["select"] extends (...args: any[]) => infer T ? T : unknown>, Error>;
-    useSuspense(params: ClientQueryArgs): UseSuspenseQueryResult<BaseQuery["select"] extends (...args: any[]) => infer T ? T : unknown, Error>;
-    invalidate(queryClient: QueryClient, params: ClientQueryArgs): Promise<void>;
-    invalidateAll(queryClient: QueryClient, params: ClientQueryArgs): Promise<void>;
+    use(params: QueryArgs<Config["url"], Config["querySchema"]>): UseQueryResult<NoInfer_2<BaseQuery["select"] extends (...args: any[]) => infer T ? T : unknown>, Error>;
+    useSuspense(params: QueryArgs<Config["url"], Config["querySchema"]>): 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>;
 };
 export { makeQueryOptions }
 export { makeQueryOptions as makeQueryOptions_alias_1 }
+export { makeQueryOptions as makeQueryOptions_alias_2 }
+
+/**
+ * Arguments for mutation functions based on URL params, request schema, and query schema.
+ */
+declare 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>;
+} : {});
+export { MutationArgs }
+export { MutationArgs as MutationArgs_alias_1 }
+export { MutationArgs as MutationArgs_alias_2 }
+
+/**
+ * Configuration for declaring a mutation endpoint.
+ */
+declare 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 = unknown, Context = unknown, UseKey extends boolean = false> {
+    method: Method;
+    url: Url;
+    querySchema?: QuerySchema;
+    responseSchema: Response;
+    requestSchema?: RequestSchema;
+    processResponse: ProcessResponseFunction<Result, ReqResult>;
+    useContext?: () => Context;
+    onSuccess?: (queryClient: QueryClient, data: NoInfer<Result>, variables: MutationArgs<Url, RequestSchema, QuerySchema>, context: Context) => void | Promise<void>;
+    onError?: (queryClient: QueryClient, error: Error, variables: MutationArgs<Url, RequestSchema, QuerySchema>, context: Context) => void | Promise<void>;
+    useKey?: UseKey;
+}
+export { MutationConfig }
+export { MutationConfig as MutationConfig_alias_1 }
+export { MutationConfig as MutationConfig_alias_2 }
 
+/**
+ * Helper methods attached to mutation hooks.
+ */
 declare type MutationHelpers<Url extends string, Result = unknown> = UrlHasParams<Url> extends true ? {
     mutationKey: (params: UrlParams<Url>) => DataTag<[Url], Result, Error>;
     useIsMutating: (keyParams: UrlParams<Url>) => boolean;
@@ -415,88 +608,145 @@ export { MutationHelpers }
 export { MutationHelpers as MutationHelpers_alias_1 }
 export { MutationHelpers as MutationHelpers_alias_2 }
 
+/** @deprecated Use createMutationKey instead */
+declare const mutationKeyCreator: typeof createMutationKey;
+export { mutationKeyCreator }
+export { mutationKeyCreator as mutationKeyCreator_alias_1 }
+export { mutationKeyCreator as mutationKeyCreator_alias_2 }
+
 /**
- * Creates a mutation key for a given endpoint configuration and options.
- *
- * @param {config: Config } config - The endpoint object containing the configuration.
-     * @param {Options} [options] - Optional query parameters with a default `processResponse` function that processes the response data.
-     *
-     * @returns {Object} An object containing the `mutationKey` function.
-     *
-     * The `mutationKey` function generates a mutation key based on the provided parameters:
-     * - If the URL has parameters (`HasParams` is `true`), it expects an object with `urlParams`.
-     * - The return type of the `mutationKey` function depends on the `processResponse` function in `options`.
-     *   If `processResponse` is defined, the return type is a `DataTag` containing the processed result and an error type.
-     *
-     * @example Example usage:
-     * ```typescript
-     * const createMutationKey = mutationKeyCreator(endpoint.config);
-     * const mutationKey = createMutationKey({ urlParams: { id: 123 } });
-     * ```
-     *
-     * @example Advanced usage:
-     * ```ts
-     * const createMutationKey = mutationKeyCreator(endpoint.config, {
-     *   processResponse: (data) => {
-     *     if (!data.success) {
-     *      throw new Error(data.message);
-     *     }
-     *     return data.data;
-     *   },
-     * });
-     * // We create a mutation that will be shared across the project for all passed userId
-     * const mutationKey = createMutationKey({ urlParams: { projectId: 123, userId: 'wildcard' } });
+ * Base parameters for mutation configuration.
+ */
+declare interface MutationParams<Config extends AnyEndpointConfig, TData = unknown, TVariables = NaviosZodRequest<Config>, TResponse = z.output<Config['responseSchema']>, TContext = unknown, UseKey extends boolean = false> extends Omit<UseMutationOptions<TData, Error, TVariables>, 'mutationKey' | 'mutationFn' | 'onSuccess' | 'onError' | 'scope'> {
+    processResponse: ProcessResponseFunction<TData, TResponse>;
+    /**
+     * 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
      */
- declare function mutationKeyCreator<Config extends AnyEndpointConfig, Options extends BaseQueryParams<Config>, Url extends Config['url'] = Config['url'], HasParams extends UrlHasParams<Url> = UrlHasParams<Url>>(config: Config, options?: Options): (params: HasParams extends true ? {
-     urlParams: UrlParams<Url>;
- } : {}) => Options['processResponse'] extends (...args: any[]) => infer Result ? DataTag<[Config['url']], Result, Error> : never;
- export { mutationKeyCreator }
- export { mutationKeyCreator as mutationKeyCreator_alias_1 }
-
- declare type ProcessResponseFunction<TData = unknown, TVariables = unknown> = (variables: TVariables) => Promise<TData> | TData;
- export { ProcessResponseFunction }
- export { ProcessResponseFunction as ProcessResponseFunction_alias_1 }
-
- declare type QueryHelpers<Url extends string, QuerySchema extends ZodObject | undefined = undefined, Result = undefined, IsInfinite extends boolean = false> = {
-     queryKey: QueryKeyCreatorResult<QuerySchema, Url, Result, IsInfinite>;
-     use: (params: Util_FlatObject<ClientQueryArgs<Url, QuerySchema>>) => UseQueryResult<Result, Error>;
-     useSuspense: (params: Util_FlatObject<ClientQueryArgs<Url, QuerySchema>>) => UseSuspenseQueryResult<Result, Error>;
-     invalidate: (queryClient: QueryClient, params: Util_FlatObject<ClientQueryArgs<Url, QuerySchema>>) => () => Promise<void>;
-     invalidateAll: (queryClient: QueryClient, params: Util_FlatObject<ClientQueryUrlParamsArgs<Url>>) => () => Promise<void>;
- };
- export { QueryHelpers }
- export { QueryHelpers as QueryHelpers_alias_1 }
- export { QueryHelpers as QueryHelpers_alias_2 }
-
- declare function queryKeyCreator<Config extends AnyEndpointConfig, Options extends BaseQueryParams<Config>, IsInfinite extends boolean, Url extends Config['url'] = Config['url'], HasParams extends UrlHasParams<Url> = UrlHasParams<Url>>(config: Config, options: Options, isInfinite: IsInfinite): QueryKeyCreatorResult<Config['querySchema'], Url, Options['processResponse'] extends (...args: any[]) => infer Result ? Result : never, IsInfinite, HasParams>;
- export { queryKeyCreator }
- export { queryKeyCreator as queryKeyCreator_alias_1 }
-
- declare type QueryKeyCreatorResult<QuerySchema = undefined, Url extends string = string, Result = unknown, IsInfinite extends boolean = false, HasParams extends UrlHasParams<Url> = UrlHasParams<Url>> = {
-     template: Split_2<Url, '/'>;
-     dataTag: (params: (HasParams extends true ? {
-         urlParams: UrlParams<Url>;
-     } : {}) & (QuerySchema extends ZodObject ? {
-         params: z.input<QuerySchema>;
-     } : {})) => DataTag<Split_2<Url, '/'>, IsInfinite extends true ? InfiniteData<Result> : Result, Error>;
-     filterKey: (params: HasParams extends true ? {
-         urlParams: UrlParams<Url>;
-     } : {}) => DataTag<Split_2<Url, '/'>, IsInfinite extends true ? InfiniteData<Result> : Result, Error>;
-     bindToUrl: (params: (HasParams extends true ? {
-         urlParams: UrlParams<Url>;
-     } : {}) & (QuerySchema extends ZodObject ? {
-         params: z.infer<QuerySchema>;
-     } : {})) => string;
- };
- export { QueryKeyCreatorResult }
- export { QueryKeyCreatorResult as QueryKeyCreatorResult_alias_1 }
-
- declare type Split<S extends string, D extends string> = string extends S ? string[] : S extends '' ? [] : S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] : [S];
- export { Split }
- export { Split as Split_alias_1 }
-
- declare type Split_2<S extends string, D extends string> = string extends S ? string[] : S extends '' ? [] : S extends `${infer T}${D}${infer U}` ? [T, ...Split_2<U, D>] : [S];
-
- declare type Split_3<S extends string, D extends string> = string extends S ? string[] : S extends '' ? [] : S extends `${infer T}${D}${infer U}` ? [T, ...Split_3<U, D>] : [S];
-
- export { }
+    useContext?: () => TContext;
+    onSuccess?: (queryClient: QueryClient, data: TData, variables: TVariables, context: TContext) => void | Promise<void>;
+    onError?: (queryClient: QueryClient, err: unknown, variables: TVariables, context: TContext) => void | Promise<void>;
+    /**
+     * If true, we will create a mutation key that can be shared across the project.
+     */
+    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;
+}
+export { MutationParams }
+export { MutationParams as MutationParams_alias_1 }
+export { MutationParams as MutationParams_alias_2 }
+
+/**
+ * Function type for processing API responses before returning to the caller.
+ */
+declare type ProcessResponseFunction<TData = unknown, TVariables = unknown> = (variables: TVariables) => Promise<TData> | TData;
+export { ProcessResponseFunction }
+export { ProcessResponseFunction as ProcessResponseFunction_alias_1 }
+export { ProcessResponseFunction as ProcessResponseFunction_alias_2 }
+
+/**
+ * Arguments for query functions based on URL params and query schema.
+ */
+declare 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>;
+} : {});
+export { QueryArgs }
+export { QueryArgs as QueryArgs_alias_1 }
+export { QueryArgs as QueryArgs_alias_2 }
+
+/**
+ * Configuration for declaring a query endpoint.
+ */
+declare interface QueryConfig<Method = HttpMethod, Url = string, QuerySchema = ZodObject, Response extends ZodType = ZodType, Result = z.output<Response>, RequestSchema = unknown> {
+    method: Method;
+    url: Url;
+    querySchema?: QuerySchema;
+    responseSchema: Response;
+    requestSchema?: RequestSchema;
+    processResponse?: (data: z.output<Response>) => Result;
+}
+export { QueryConfig }
+export { QueryConfig as QueryConfig_alias_1 }
+export { QueryConfig as QueryConfig_alias_2 }
+
+/**
+ * Helper methods attached to query options.
+ */
+declare type QueryHelpers<Url extends string, QuerySchema extends ZodObject | undefined = undefined, Result = undefined, IsInfinite extends boolean = false, RequestSchema extends ZodType | undefined = undefined> = {
+    queryKey: QueryKeyCreatorResult<QuerySchema, Url, Result, IsInfinite>;
+    use: (params: Util_FlatObject<QueryArgs<Url, QuerySchema, RequestSchema>>) => UseQueryResult<Result, Error>;
+    useSuspense: (params: Util_FlatObject<QueryArgs<Url, QuerySchema, RequestSchema>>) => UseSuspenseQueryResult<Result, Error>;
+    invalidate: (queryClient: QueryClient, params: Util_FlatObject<QueryArgs<Url, QuerySchema, RequestSchema>>) => () => Promise<void>;
+    invalidateAll: (queryClient: QueryClient, params: Util_FlatObject<QueryUrlParamsArgs<Url>>) => () => Promise<void>;
+};
+export { QueryHelpers }
+export { QueryHelpers as QueryHelpers_alias_1 }
+export { QueryHelpers as QueryHelpers_alias_2 }
+
+/** @deprecated Use createQueryKey instead */
+declare const queryKeyCreator: typeof createQueryKey;
+export { queryKeyCreator }
+export { queryKeyCreator as queryKeyCreator_alias_1 }
+export { queryKeyCreator as queryKeyCreator_alias_2 }
+
+/**
+ * Result type from the query key creator function.
+ */
+declare type QueryKeyCreatorResult<QuerySchema = undefined, Url extends string = string, Result = unknown, IsInfinite extends boolean = false, HasParams extends UrlHasParams<Url> = UrlHasParams<Url>> = {
+    template: Split<Url, '/'>;
+    dataTag: (params: (HasParams extends true ? {
+        urlParams: UrlParams<Url>;
+    } : {}) & (QuerySchema extends ZodObject ? {
+        params: z.input<QuerySchema>;
+    } : {})) => DataTag<Split<Url, '/'>, IsInfinite extends true ? InfiniteData<Result> : Result, Error>;
+    filterKey: (params: HasParams extends true ? {
+        urlParams: UrlParams<Url>;
+    } : {}) => DataTag<Split<Url, '/'>, IsInfinite extends true ? InfiniteData<Result> : Result, Error>;
+    bindToUrl: (params: (HasParams extends true ? {
+        urlParams: UrlParams<Url>;
+    } : {}) & (QuerySchema extends ZodObject ? {
+        params: z.infer<QuerySchema>;
+    } : {})) => string;
+};
+export { QueryKeyCreatorResult }
+export { QueryKeyCreatorResult as QueryKeyCreatorResult_alias_1 }
+export { QueryKeyCreatorResult as QueryKeyCreatorResult_alias_2 }
+
+/**
+ * Base parameters for query configuration.
+ */
+declare type QueryParams<Config extends AnyEndpointConfig, Res = any> = {
+    keyPrefix?: string[];
+    keySuffix?: string[];
+    onFail?: (err: unknown) => void;
+    processResponse: (data: z.output<Config['responseSchema']>) => Res;
+};
+export { QueryParams }
+export { QueryParams as QueryParams_alias_1 }
+export { QueryParams as QueryParams_alias_2 }
+
+/**
+ * Arguments containing only URL params (for invalidateAll operations).
+ */
+declare type QueryUrlParamsArgs<Url extends string = string> = UrlHasParams<Url> extends true ? {
+    urlParams: UrlParams<Url>;
+} : {} | undefined;
+export { QueryUrlParamsArgs }
+export { QueryUrlParamsArgs as QueryUrlParamsArgs_alias_1 }
+export { QueryUrlParamsArgs as QueryUrlParamsArgs_alias_2 }
+
+/**
+ * Splits a string by a delimiter into a tuple type.
+ * Used for parsing URL paths into segments for query keys.
+ */
+declare type Split<S extends string, D extends string> = string extends S ? string[] : S extends '' ? [] : S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] : [S];
+export { Split }
+export { Split as Split_alias_1 }
+export { Split as Split_alias_2 }
+
+export { }