@navios/react-query 0.1.0 → 0.1.1

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

@@ -0,0 +1,448 @@
+import type { AbstractEndpoint } from '@navios/common';
+import type { AnyEndpointConfig } from '@navios/common';
+import type { AnyZodObject } from 'zod';
+import type { BaseEndpointConfig } from '@navios/common';
+import type { BuilderInstance } from '@navios/common';
+import type { DataTag } from '@tanstack/react-query';
+import { DefinedUseInfiniteQueryResult } from '@tanstack/react-query';
+import type { EndpointFunctionArgs } from '@navios/common';
+import type { HttpMethod } from '@navios/common';
+import type { InfiniteData } from '@tanstack/react-query';
+import type { NaviosZodRequest } from '@navios/common';
+import type { QueryClient } from '@tanstack/react-query';
+import { QueryKeyCreatorResult as QueryKeyCreatorResult_2 } from './utils/query-key-creator.mjs';
+import { UrlHasParams } from '@navios/common';
+import type { UrlParams } from '@navios/common';
+import type { UseInfiniteQueryOptions } from '@tanstack/react-query';
+import { UseInfiniteQueryResult } from '@tanstack/react-query';
+import type { UseMutationOptions } from '@tanstack/react-query';
+import type { UseMutationResult } from '@tanstack/react-query';
+import type { UseQueryOptions } from '@tanstack/react-query';
+import type { UseQueryResult } from '@tanstack/react-query';
+import type { UseSuspenseInfiniteQueryOptions } from '@tanstack/react-query';
+import { UseSuspenseInfiniteQueryResult } from '@tanstack/react-query';
+import type { UseSuspenseQueryOptions } from '@tanstack/react-query';
+import type { UseSuspenseQueryResult } from '@tanstack/react-query';
+import type { Util_FlatObject } from '@navios/common';
+import type { z } from 'zod';
+import type { ZodType } from 'zod';
+
+declare type BaseMutationArgs<Config extends AnyEndpointConfig> = NaviosZodRequest<Config>;
+export { BaseMutationArgs }
+export { BaseMutationArgs as BaseMutationArgs_alias_1 }
+
+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;
+}
+export { BaseMutationParams }
+export { BaseMutationParams as BaseMutationParams_alias_1 }
+
+declare type BaseQueryArgs<Config extends AnyEndpointConfig> = (UrlHasParams<Config['url']> extends true ? {
+    urlParams: UrlParams<Config['url']>;
+} : {}) & (Config['querySchema'] extends AnyZodObject ? {
+    params: z.input<Config['querySchema']>;
+} : {});
+export { BaseQueryArgs }
+export { BaseQueryArgs as BaseQueryArgs_alias_1 }
+
+declare type BaseQueryParams<Config extends AnyEndpointConfig, Res = any> = {
+    keyPrefix?: string[];
+    keySuffix?: string[];
+    onFail?: (err: unknown) => void;
+    processResponse: (data: z.output<Config['responseSchema']>) => Res;
+};
+export { BaseQueryParams }
+export { BaseQueryParams as BaseQueryParams_alias_1 }
+
+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>;
+    };
+};
+export { ClientEndpointHelper }
+export { ClientEndpointHelper as ClientEndpointHelper_alias_1 }
+export { ClientEndpointHelper as ClientEndpointHelper_alias_2 }
+
+declare type ClientInfiniteQueryConfig<Method = HttpMethod, Url = string, QuerySchema extends AnyZodObject = AnyZodObject, 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 }
+
+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>;
+    query<Method extends 'GET' | 'HEAD' | 'OPTIONS' = 'GET', Url extends string = string, QuerySchema extends AnyZodObject = AnyZodObject, 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>;
+    infiniteQuery<Method extends 'GET' | 'HEAD' | 'OPTIONS' = 'GET', Url extends string = string, QuerySchema extends AnyZodObject = AnyZodObject, Response extends ZodType = ZodType, PageResult = z.output<Response>, Result = 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<ClientQueryArgs<Url, QuerySchema>>) => UseSuspenseInfiniteQueryOptions<PageResult, Error, Result, PageResult, DataTag<Split<Url, '/'>, PageResult, Error>, z.output<QuerySchema>>) & QueryHelpers<Url, QuerySchema, PageResult, true> & ClientEndpointHelper<Method, Url, undefined, Response, QuerySchema>;
+    mutation<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, QuerySchema extends AnyZodObject = AnyZodObject, 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<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: UrlParams<Url>;
+    } : {}) => UseMutationResult<Result, Error, ClientMutationArgs<Url, RequestSchema, QuerySchema>>) & MutationHelpers<Url, Result> & ClientEndpointHelper<Method, Url, RequestSchema, Response, QuerySchema>;
+    mutation<Method extends 'POST' | 'PUT' | 'PATCH' = 'POST' | 'PUT' | 'PATCH', Url extends string = string, RequestSchema extends ZodType = ZodType, QuerySchema extends AnyZodObject = AnyZodObject, 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<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: UrlParams<Url>;
+    } : {}) => UseMutationResult<Result, Error, ClientMutationArgs<Url, RequestSchema, QuerySchema>> & ClientEndpointHelper<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;
+        requestSchema: RequestSchema;
+        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: UrlParams<Url>;
+    } : {}) => UseMutationResult<Result, Error, ClientMutationArgs<Url, RequestSchema, undefined>>) & MutationHelpers<Url, Result> & ClientEndpointHelper<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;
+        useKey: UseKey;
+        requestSchema: RequestSchema;
+        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: UrlParams<Url>;
+    } : {}) => UseMutationResult<Result, Error, ClientMutationArgs<Url, RequestSchema, undefined>>) & MutationHelpers<Url, Result> & ClientEndpointHelper<Method, Url, RequestSchema, Response>;
+    mutation<Method extends 'DELETE' = 'DELETE', Url extends string = string, QuerySchema extends AnyZodObject = AnyZodObject, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result = unknown, Context = unknown, UseKey extends true = true>(config: {
+        method: Method;
+        url: Url;
+        useKey: UseKey;
+        querySchema: QuerySchema;
+        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: UrlParams<Url>;
+    } : {}) => UseMutationResult<Result, Error, ClientMutationArgs<Url, undefined, QuerySchema>>) & MutationHelpers<Url, Result> & ClientEndpointHelper<Method, Url, undefined, Response, QuerySchema>;
+    mutation<Method extends 'DELETE' = 'DELETE', Url extends string = string, QuerySchema extends AnyZodObject = AnyZodObject, Response extends ZodType = ZodType, ReqResult = z.output<Response>, Result = unknown, Context = unknown>(config: {
+        method: Method;
+        url: Url;
+        querySchema: QuerySchema;
+        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: UrlParams<Url>;
+    } : {}) => UseMutationResult<Result, Error, ClientMutationArgs<Url, undefined, QuerySchema>> & ClientEndpointHelper<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;
+        useKey: UseKey;
+        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: UrlParams<Url>;
+    } : {}) => UseMutationResult<Result, Error, ClientMutationArgs<Url, undefined, undefined>>) & MutationHelpers<Url, Result> & ClientEndpointHelper<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>;
+    }): (params: UrlHasParams<Url> extends true ? {
+        urlParams: UrlParams<Url>;
+    } : {}) => 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 AnyZodObject = AnyZodObject, Response extends ZodType = ZodType, Result = z.output<Response>>(endpoint: any & {
+        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 & {
+        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 AnyZodObject = AnyZodObject, Response extends ZodType = ZodType, PageResult = z.output<Response>, Result = InfiniteData<PageResult>>(endpoint: any & {
+        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, PageResult, DataTag<Split<Url, '/'>, PageResult, Error>, z.output<QuerySchema>> & QueryHelpers<Url, QuerySchema, PageResult, true>;
+}
+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 AnyZodObject ? {
+    data: z.input<RequestSchema>;
+} : {}) & (QuerySchema extends AnyZodObject ? {
+    params: z.input<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 : AnyZodObject, 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> = {
+    api: BuilderInstance;
+    defaults?: {
+        keyPrefix?: string[];
+        keySuffix?: string[];
+    };
+};
+export { ClientOptions }
+export { ClientOptions as ClientOptions_alias_1 }
+
+declare type ClientQueryArgs<Url extends string = string, QuerySchema = AnyZodObject> = (UrlHasParams<Url> extends true ? {
+    urlParams: UrlParams<Url>;
+} : {}) & (QuerySchema extends AnyZodObject ? {
+    params: z.input<QuerySchema>;
+} : {});
+export { ClientQueryArgs }
+export { ClientQueryArgs as ClientQueryArgs_alias_1 }
+export { ClientQueryArgs as ClientQueryArgs_alias_2 }
+
+declare interface ClientQueryConfig<Method = HttpMethod, Url = string, QuerySchema = AnyZodObject, 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;
+export { ClientQueryUrlParamsArgs }
+export { ClientQueryUrlParamsArgs as ClientQueryUrlParamsArgs_alias_1 }
+export { ClientQueryUrlParamsArgs as ClientQueryUrlParamsArgs_alias_2 }
+
+declare function declareClient<Options extends ClientOptions>({ api, defaults, }: Options): ClientInstance;
+export { declareClient }
+export { declareClient as declareClient_alias_1 }
+
+declare type InfiniteQueryOptions<Config extends BaseEndpointConfig<HttpMethod, string, AnyZodObject>, Res = any> = {
+    keyPrefix?: string[];
+    keySuffix?: string[];
+    processResponse: (data: z.infer<Config['responseSchema']>) => Res;
+    onFail?: (err: unknown) => void;
+    getNextPageParam: (lastPage: z.infer<Config['responseSchema']>, allPages: z.infer<Config['responseSchema']>[], lastPageParam: z.infer<Config['querySchema']> | undefined, allPageParams: z.infer<Config['querySchema']>[] | undefined) => z.input<Config['querySchema']> | z.infer<Config['querySchema']> | undefined;
+    initialPageParam?: z.input<Config['querySchema']> | z.infer<Config['querySchema']>;
+};
+export { InfiniteQueryOptions }
+export { InfiniteQueryOptions as InfiniteQueryOptions_alias_1 }
+
+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;
+    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>;
+};
+export { makeInfiniteQueryOptions }
+export { makeInfiniteQueryOptions as makeInfiniteQueryOptions_alias_1 }
+
+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>>;
+    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>;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export { makeMutation }
+export { makeMutation as makeMutation_alias_1 }
+
+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;
+    queryKey: QueryKeyCreatorResult_2<Config["querySchema"], Config["url"], Options["processResponse"] extends (...args: any[]) => infer Result ? Result : never, false, UrlHasParams<Config["url"]>>;
+    use(params: ClientQueryArgs): DefinedUseInfiniteQueryResult<BaseQuery["select"] extends (...args: any[]) => infer T ? T : unknown, Error>;
+    useSuspense(params: ClientQueryArgs): UseSuspenseInfiniteQueryResult<BaseQuery["select"] extends (...args: any[]) => infer T ? T : unknown, Error>;
+    invalidate(queryClient: QueryClient, params: ClientQueryArgs): Promise<void>;
+    invalidateAll(queryClient: QueryClient, params: ClientQueryArgs): Promise<void>;
+};
+export { makeQueryOptions }
+export { makeQueryOptions as makeQueryOptions_alias_1 }
+
+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;
+} : {
+    mutationKey: () => DataTag<[Url], Result, Error>;
+    useIsMutating: () => boolean;
+};
+export { MutationHelpers }
+export { MutationHelpers as MutationHelpers_alias_1 }
+export { MutationHelpers as MutationHelpers_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' } });
+     */
+ 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 AnyZodObject | 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 AnyZodObject ? {
+         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 AnyZodObject ? {
+         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 { }