import { type UseQueryResult, type UseMutationResult, type QueryKey, type QueryObserverOptions } from "@tanstack/react-query";
import { Reactor, BaseActor, FunctionName, TransformKey, ReactorArgs, ReactorReturnOk, ReactorReturnErr, FunctionType } from "@ic-reactor/core";
import { CallConfig } from "@icp-sdk/core/agent";
/**
 * Configuration for useActorMethod hook.
 * Extends react-query's QueryObserverOptions with custom reactor params.
 *
 * This is a unified hook that handles both query and mutation methods.
 * Query-specific options (like refetchInterval) only apply to query methods.
 * Mutation-specific options (like invalidateQueries) only apply to mutation methods.
 */
export interface UseActorMethodParameters<A = BaseActor, M extends FunctionName<A> = FunctionName<A>, T extends TransformKey = "candid"> extends Omit<QueryObserverOptions<ReactorReturnOk<A, M, T>, ReactorReturnErr<A, M, T>, ReactorReturnOk<A, M, T>, ReactorReturnOk<A, M, T>, QueryKey>, "queryKey" | "queryFn"> {
    /** The reactor instance to use for method calls */
    reactor: Reactor<A, T>;
    /** The method name to call on the canister */
    functionName: M;
    /** Arguments to pass to the method (optional for parameterless methods) */
    args?: ReactorArgs<A, M, T>;
    /** Agent call configuration (effectiveCanisterId, etc.) */
    callConfig?: CallConfig;
    /** Custom query key (auto-generated if not provided) */
    queryKey?: QueryKey;
    /**
     * Callback when the method call succeeds.
     * Works for both query and mutation methods.
     */
    onSuccess?: (data: ReactorReturnOk<A, M, T>) => void;
    /**
     * Callback when the method call fails.
     * Works for both query and mutation methods.
     */
    onError?: (error: ReactorReturnErr<A, M, T>) => void;
    /**
     * Query keys to invalidate after a successful mutation.
     * Only applies to mutation methods (updates).
     */
    invalidateQueries?: QueryKey[];
}
/**
 * Configuration type for bound useActorMethod hook (reactor omitted).
 * For use with createActorHooks.
 */
export type UseActorMethodConfig<A = BaseActor, M extends FunctionName<A> = FunctionName<A>, T extends TransformKey = "candid"> = Omit<UseActorMethodParameters<A, M, T>, "reactor">;
/**
 * Result type for useActorMethod hook.
 * Provides a unified interface for both query and mutation methods.
 */
export interface UseActorMethodResult<A = BaseActor, M extends FunctionName<A> = FunctionName<A>, T extends TransformKey = "candid"> {
    /** The returned data from the method call */
    data: ReactorReturnOk<A, M, T> | undefined;
    /** Whether the method is currently executing */
    isLoading: boolean;
    /** Alias for isLoading - whether a mutation is pending */
    isPending: boolean;
    /** Whether there was an error */
    isError: boolean;
    /** Whether the method has successfully completed at least once */
    isSuccess: boolean;
    /** The error if one occurred */
    error: ReactorReturnErr<A, M, T> | null;
    /** Whether this is a query method (true) or mutation method (false) */
    isQuery: boolean;
    /** The function type (query, update, composite_query) */
    functionType: FunctionType;
    /**
     * Call the method with optional arguments.
     * For queries: triggers a refetch
     * For mutations: executes the mutation with the provided args
     */
    call: (args?: ReactorArgs<A, M, T>) => Promise<ReactorReturnOk<A, M, T> | undefined>;
    /**
     * Reset the state (clear data and error).
     * For queries: removes the query from cache
     * For mutations: resets the mutation state
     */
    reset: () => void;
    /**
     * For queries only: Refetch the query
     */
    refetch: () => Promise<ReactorReturnOk<A, M, T> | undefined>;
    /** The raw query result (only available for query methods) */
    queryResult?: UseQueryResult<ReactorReturnOk<A, M, T>, ReactorReturnErr<A, M, T>>;
    /** The raw mutation result (only available for mutation methods) */
    mutationResult?: UseMutationResult<ReactorReturnOk<A, M, T>, ReactorReturnErr<A, M, T>, ReactorArgs<A, M, T>>;
}
/**
 * A unified hook for calling canister methods that automatically handles
 * both query and mutation methods based on the Candid interface.
 */
export declare function useActorMethod<A = BaseActor, M extends FunctionName<A> = FunctionName<A>, T extends TransformKey = "candid">({ reactor, functionName, args, callConfig, queryKey: customQueryKey, enabled, onSuccess, onError, invalidateQueries, ...queryOptions }: UseActorMethodParameters<A, M, T>): UseActorMethodResult<A, M, T>;
/**
 * Creates a bound useMethod hook for a specific reactor instance.
 *
 * @example
 * ```tsx
 * const { useMethod } = createActorMethodHooks(reactor)
 * ```
 */
export declare function createActorMethodHooks<A = BaseActor, T extends TransformKey = "candid">(reactor: Reactor<A, T>): {
    /**
     * Hook for calling methods on the bound reactor.
     */
    useMethod: <M extends FunctionName<A>>(config: Omit<UseActorMethodParameters<A, M, T>, "reactor">) => UseActorMethodResult<A, M, T>;
};
//# sourceMappingURL=useActorMethod.d.ts.map