import { QueryKey, UseMutationResult } from '@tanstack/react-query';
import { ApiError, RequestConfig, QueryParams } from '../types';
/**
 * Mutation variables structure
 */
export interface MutationVariables<TBody = unknown> {
    /** Request body */
    body?: TBody;
    /** Path parameters */
    pathParams?: Record<string, string | number>;
    /** Query parameters */
    queryParams?: QueryParams;
}
/**
 * API mutation configuration
 */
export interface ApiMutationConfig<TResponse = unknown, TBody = unknown, TContext = unknown> {
    /** HTTP method */
    method: 'POST' | 'PUT' | 'PATCH' | 'DELETE';
    /** Request URL (can include :param placeholders) */
    url: string;
    /** Additional request options */
    requestOptions?: Partial<RequestConfig>;
    /** Query keys to invalidate on success */
    invalidateQueries?: QueryKey[];
    /** Query keys to refetch on success */
    refetchQueries?: QueryKey[];
    /** Query key for optimistic updates */
    optimisticQueryKey?: QueryKey;
    /** Optimistic update function */
    optimisticUpdate?: (oldData: unknown, variables: MutationVariables<TBody>) => unknown;
    /** On mutate callback (for custom optimistic updates) */
    onMutate?: (variables: MutationVariables<TBody>) => Promise<TContext> | TContext;
    /** On success callback */
    onSuccess?: (data: TResponse, variables: MutationVariables<TBody>, context: TContext | undefined) => void | Promise<void>;
    /** On error callback */
    onError?: (error: ApiError, variables: MutationVariables<TBody>, context: TContext | undefined) => void | Promise<void>;
    /** On settled callback */
    onSettled?: (data: TResponse | undefined, error: ApiError | null, variables: MutationVariables<TBody>, context: TContext | undefined) => void | Promise<void>;
    /** Retry configuration */
    retry?: number | boolean;
    /** Retry delay */
    retryDelay?: number;
}
/**
 * Return type for useApiMutation
 */
export interface UseApiMutationResult<TResponse, TBody = unknown> extends Omit<UseMutationResult<TResponse, ApiError, MutationVariables<TBody>>, never> {
    /** Execute mutation with just body */
    mutateWithBody: (body: TBody) => void;
    /** Execute mutation async with just body */
    mutateAsyncWithBody: (body: TBody) => Promise<TResponse>;
}
/**
 * Hook for making typed API mutations
 *
 * @typeParam TResponse - Expected response data type
 * @typeParam TBody - Request body type
 * @typeParam TContext - Mutation context type (for optimistic updates)
 * @param config - Mutation configuration
 * @returns Mutation result with utilities
 *
 * @example
 * ```typescript
 * // Create mutation
 * const createUser = useApiMutation<User, CreateUserDto>({
 *   method: 'POST',
 *   url: '/users',
 *   invalidateQueries: [['users', 'list']],
 * });
 *
 * // Execute
 * createUser.mutate({ body: { name: 'John', email: 'john@example.com' } });
 *
 * // Or with simplified API
 * createUser.mutateWithBody({ name: 'John', email: 'john@example.com' });
 *
 * // Update mutation with path params
 * const updateUser = useApiMutation<User, UpdateUserDto>({
 *   method: 'PATCH',
 *   url: '/users/:id',
 *   invalidateQueries: [['users', 'list']],
 * });
 *
 * updateUser.mutate({
 *   pathParams: { id: '123' },
 *   body: { name: 'Updated Name' },
 * });
 *
 * // Delete mutation
 * const deleteUser = useApiMutation<void>({
 *   method: 'DELETE',
 *   url: '/users/:id',
 *   invalidateQueries: [['users', 'list']],
 * });
 *
 * deleteUser.mutate({ pathParams: { id: '123' } });
 * ```
 */
export declare function useApiMutation<TResponse = unknown, TBody = unknown, TContext = unknown>(config: ApiMutationConfig<TResponse, TBody, TContext>): UseApiMutationResult<TResponse, TBody>;
/**
 * Hook for POST mutations
 *
 * @example
 * ```typescript
 * const createUser = usePost<User, CreateUserDto>('/users', {
 *   invalidateQueries: [['users', 'list']],
 * });
 *
 * createUser.mutateWithBody({ name: 'John' });
 * ```
 */
export declare function usePost<TResponse = unknown, TBody = unknown, TContext = unknown>(url: string, options?: Omit<ApiMutationConfig<TResponse, TBody, TContext>, 'method' | 'url'>): UseApiMutationResult<TResponse, TBody>;
/**
 * Hook for PUT mutations
 *
 * @example
 * ```typescript
 * const updateUser = usePut<User, UpdateUserDto>('/users/:id', {
 *   invalidateQueries: [['users', 'list']],
 * });
 *
 * updateUser.mutate({
 *   pathParams: { id: '123' },
 *   body: { name: 'Updated' },
 * });
 * ```
 */
export declare function usePut<TResponse = unknown, TBody = unknown, TContext = unknown>(url: string, options?: Omit<ApiMutationConfig<TResponse, TBody, TContext>, 'method' | 'url'>): UseApiMutationResult<TResponse, TBody>;
/**
 * Hook for PATCH mutations
 *
 * @example
 * ```typescript
 * const patchUser = usePatch<User, Partial<User>>('/users/:id');
 *
 * patchUser.mutate({
 *   pathParams: { id: '123' },
 *   body: { status: 'active' },
 * });
 * ```
 */
export declare function usePatch<TResponse = unknown, TBody = unknown, TContext = unknown>(url: string, options?: Omit<ApiMutationConfig<TResponse, TBody, TContext>, 'method' | 'url'>): UseApiMutationResult<TResponse, TBody>;
/**
 * Hook for DELETE mutations
 *
 * @example
 * ```typescript
 * const deleteUser = useDelete<void>('/users/:id', {
 *   invalidateQueries: [['users', 'list']],
 * });
 *
 * deleteUser.mutate({ pathParams: { id: '123' } });
 * ```
 */
export declare function useDelete<TResponse = unknown, TContext = unknown>(url: string, options?: Omit<ApiMutationConfig<TResponse, never, TContext>, 'method' | 'url'>): UseApiMutationResult<TResponse, never>;
/**
 * Create optimistic update configuration for adding item to list
 *
 * @example
 * ```typescript
 * const createUser = usePost<User, CreateUserDto>('/users', {
 *   ...createOptimisticAdd(['users', 'list'], (body) => ({
 *     ...body,
 *     id: 'temp-id',
 *     createdAt: new Date().toISOString(),
 *   })),
 * });
 * ```
 */
export declare function createOptimisticAdd<TItem>(queryKey: QueryKey, createTempItem: (body: unknown) => TItem): Pick<ApiMutationConfig<TItem, unknown, {
    previousData: TItem[] | undefined;
}>, 'optimisticQueryKey' | 'optimisticUpdate'>;
/**
 * Create optimistic update configuration for updating item in list
 *
 * @example
 * ```typescript
 * const updateUser = usePatch<User, Partial<User>>('/users/:id', {
 *   ...createOptimisticUpdate<User>(['users', 'list'], (item) => item.id),
 * });
 * ```
 */
export declare function createOptimisticUpdate<TItem extends Record<string, unknown>>(queryKey: QueryKey, getItemId: (item: TItem) => string | number): Pick<ApiMutationConfig<TItem, Partial<TItem>, {
    previousData: TItem[] | undefined;
}>, 'optimisticQueryKey' | 'optimisticUpdate'>;
/**
 * Create optimistic update configuration for removing item from list
 *
 * @example
 * ```typescript
 * const deleteUser = useDelete<void>('/users/:id', {
 *   ...createOptimisticRemove<User>(['users', 'list'], (item) => item.id),
 * });
 * ```
 */
export declare function createOptimisticRemove<TItem>(queryKey: QueryKey, getItemId: (item: TItem) => string | number): Pick<ApiMutationConfig<void, never, {
    previousData: TItem[] | undefined;
}>, 'optimisticQueryKey' | 'optimisticUpdate'>;
/**
 * Hook for executing multiple mutations in sequence
 *
 * @example
 * ```typescript
 * const batchUpdate = useBatchMutation<User, UpdateUserDto>(
 *   '/users/:id',
 *   'PATCH'
 * );
 *
 * await batchUpdate.mutateAsync([
 *   { pathParams: { id: '1' }, body: { status: 'active' } },
 *   { pathParams: { id: '2' }, body: { status: 'active' } },
 * ]);
 * ```
 */
export declare function useBatchMutation<TResponse = unknown, TBody = unknown>(url: string, method: 'POST' | 'PUT' | 'PATCH' | 'DELETE', options?: Omit<ApiMutationConfig<TResponse[], TBody>, 'method' | 'url'>): {
    mutate: (variables: MutationVariables<TBody>[]) => void;
    mutateAsync: (variables: MutationVariables<TBody>[]) => Promise<TResponse[]>;
    isPending: boolean;
    isError: boolean;
    error: ApiError | null;
    data: TResponse[] | undefined;
    reset: () => void;
};