/**
 * Suspense Infinite Query Factory - Generic wrapper for React Query suspense-based paginated canister data
 *
 * Creates unified fetch/hook/invalidate functions for any paginated canister method.
 * Works with any Reactor instance.
 *
 * Uses `useSuspenseInfiniteQuery` which:
 * - Requires wrapping in <Suspense> boundary
 * - Data is always defined (no undefined checks)
 * - Does NOT support `enabled` or `placeholderData` options
 *
 * @example
 * const postsQuery = createSuspenseInfiniteQuery(reactor, {
 *   functionName: "get_posts",
 *   initialPageParam: 0,
 *   getArgs: (cursor) => [{ cursor, limit: 10 }],
 *   getNextPageParam: (lastPage) => lastPage.nextCursor,
 * })
 *
 * // In component (wrap in Suspense)
 * const { data, fetchNextPage, hasNextPage } = postsQuery.useSuspenseInfiniteQuery()
 *
 * // Flatten all pages
 * const allPosts = data.pages.flatMap(page => page.posts)
 */
import type { Reactor, FunctionName, ReactorArgs, BaseActor, TransformKey, ReactorReturnOk, ReactorReturnErr } from "@ic-reactor/core";
import { QueryKey, InfiniteData, UseSuspenseInfiniteQueryResult, UseSuspenseInfiniteQueryOptions, InfiniteQueryObserverOptions } from "@tanstack/react-query";
import { CallConfig } from "@icp-sdk/core/agent";
import { NoInfer } from "./types";
type SuspenseInfiniteFactoryCallOptions = {
    queryKey?: QueryKey;
};
type SuspenseInfiniteQueryFactoryFn<A, M extends FunctionName<A>, T extends TransformKey, TPageParam, TSelected> = {
    (getArgs: (pageParam: TPageParam) => ReactorArgs<A, M, T>): SuspenseInfiniteQueryResult<SuspenseInfiniteQueryPageData<A, M, T>, TPageParam, TSelected, SuspenseInfiniteQueryError<A, M, T>>;
    (getArgs: (pageParam: TPageParam) => ReactorArgs<A, M, T>, options?: SuspenseInfiniteFactoryCallOptions): SuspenseInfiniteQueryResult<SuspenseInfiniteQueryPageData<A, M, T>, TPageParam, TSelected, SuspenseInfiniteQueryError<A, M, T>>;
};
/** The raw page data type returned by the query function */
export type SuspenseInfiniteQueryPageData<A = BaseActor, M extends FunctionName<A> = FunctionName<A>, T extends TransformKey = "candid"> = ReactorReturnOk<A, M, T>;
/** The error type for infinite queries */
export type SuspenseInfiniteQueryError<A = BaseActor, M extends FunctionName<A> = FunctionName<A>, T extends TransformKey = "candid"> = ReactorReturnErr<A, M, T>;
/**
 * Configuration for createActorSuspenseInfiniteQuery.
 * Extends InfiniteQueryObserverOptions to accept all React Query options at the create level.
 *
 * @template A - The actor interface type
 * @template M - The method name on the actor
 * @template T - The transformation key (identity, display, etc.)
 * @template TPageParam - The type of the page parameter
 * @template TSelected - The type returned after select transformation
 */
export interface SuspenseInfiniteQueryConfig<A = BaseActor, M extends FunctionName<A> = FunctionName<A>, T extends TransformKey = "candid", TPageParam = unknown, TSelected = InfiniteData<SuspenseInfiniteQueryPageData<A, M, T>, TPageParam>> extends Omit<InfiniteQueryObserverOptions<SuspenseInfiniteQueryPageData<A, M, T>, SuspenseInfiniteQueryError<A, M, T>, TSelected, QueryKey, TPageParam>, "queryKey" | "queryFn"> {
    /** The method to call on the canister */
    functionName: M;
    /** Call configuration for the actor method */
    callConfig?: CallConfig;
    /** Custom query key (optional, auto-generated if not provided) */
    queryKey?: QueryKey;
    /** Function to get args from page parameter */
    getArgs: (pageParam: TPageParam) => ReactorArgs<A, M, T>;
}
/**
 * Configuration for createActorSuspenseInfiniteQueryFactory (without getArgs; provided at call time).
 */
export type SuspenseInfiniteQueryFactoryConfig<A = BaseActor, M extends FunctionName<A> = FunctionName<A>, T extends TransformKey = "candid", TPageParam = unknown, TSelected = InfiniteData<SuspenseInfiniteQueryPageData<A, M, T>, TPageParam>> = Omit<SuspenseInfiniteQueryConfig<A, M, T, TPageParam, TSelected>, "getArgs"> & {
    /**
     * Optional key-args derivation for factory calls.
     * Receives the resolved args from `getArgs(initialPageParam)` and should return
     * a stable serializable representation of the logical query identity
     * (typically excluding pagination/cursor fields).
     */
    getKeyArgs?: (args: ReactorArgs<A, M, T>) => unknown;
};
/**
 * useSuspenseInfiniteQuery hook with chained select support.
 */
export interface UseSuspenseInfiniteQueryWithSelect<TPageData, TPageParam, TSelected = InfiniteData<TPageData, TPageParam>, TError = Error> {
    (options?: Omit<UseSuspenseInfiniteQueryOptions<TPageData, TError, TSelected, QueryKey, TPageParam>, "select" | "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam" | "getPreviousPageParam">): UseSuspenseInfiniteQueryResult<TSelected, TError>;
    <TFinal = TSelected>(options: Omit<UseSuspenseInfiniteQueryOptions<TPageData, TError, TFinal, QueryKey, TPageParam>, "queryKey" | "queryFn" | "select" | "initialPageParam" | "getNextPageParam" | "getPreviousPageParam"> & {
        select: (data: TSelected) => TFinal;
    }): UseSuspenseInfiniteQueryResult<TFinal, TError>;
}
/**
 * Result from createActorSuspenseInfiniteQuery
 *
 * @template TPageData - The raw page data type
 * @template TPageParam - The page parameter type
 * @template TSelected - The type after select transformation
 * @template TError - The error type
 */
export interface SuspenseInfiniteQueryResult<TPageData, TPageParam, TSelected = InfiniteData<TPageData, TPageParam>, TError = Error> {
    /** Fetch first page in loader (uses ensureInfiniteQueryData for cache-first) */
    fetch: () => Promise<TSelected>;
    /** React hook for components - supports pagination */
    useSuspenseInfiniteQuery: UseSuspenseInfiniteQueryWithSelect<TPageData, TPageParam, TSelected, TError>;
    /** Invalidate the cache (refetches if query is active) */
    invalidate: () => Promise<void>;
    /** Get query key (for advanced React Query usage) */
    getQueryKey: () => QueryKey;
    /**
     * Read data directly from cache without fetching.
     * Returns undefined if data is not in cache.
     */
    getCacheData: {
        (): TSelected | undefined;
        <TFinal>(select: (data: TSelected) => TFinal): TFinal | undefined;
    };
}
export declare function createSuspenseInfiniteQuery<A, T extends TransformKey, M extends FunctionName<A> = FunctionName<A>, TPageParam = unknown, TSelected = InfiniteData<SuspenseInfiniteQueryPageData<A, M, T>, TPageParam>>(reactor: Reactor<A, T>, config: SuspenseInfiniteQueryConfig<NoInfer<A>, M, T, TPageParam, TSelected>): SuspenseInfiniteQueryResult<SuspenseInfiniteQueryPageData<A, M, T>, TPageParam, TSelected, SuspenseInfiniteQueryError<A, M, T>>;
/**
 * Create a suspense infinite query factory that accepts getArgs at call time.
 * Useful when pagination logic varies by context.
 *
 * @template A - The actor interface type
 * @template M - The method name on the actor
 * @template T - The transformation key (identity, display, etc.)
 * @template TPageParam - The page parameter type
 * @template TSelected - The type returned after select transformation
 *
 * @param reactor - The Reactor instance
 * @param config - Suspense infinite query configuration (without getArgs)
 * @returns A function that accepts getArgs and returns an SuspenseActorInfiniteQueryResult
 *
 * @example
 * const getPostsQuery = createActorSuspenseInfiniteQueryFactory(reactor, {
 *   functionName: "get_posts",
 *   initialPageParam: 0,
 *   getKeyArgs: (args) => {
 *     const [{ userId }] = args
 *     return [{ userId }]
 *   },
 *   getNextPageParam: (lastPage) => lastPage.nextCursor,
 * })
 *
 * // Create query with specific args builder
 * const userPostsQuery = getPostsQuery((cursor) => [{ userId, cursor, limit: 10 }])
 * const { data, fetchNextPage } = userPostsQuery.useSuspenseInfiniteQuery()
 *
 * // Optional: append a manual query-key suffix in addition to auto key args
 * const scopedPostsQuery = getPostsQuery(
 *   (cursor) => [{ userId, cursor, limit: 10 }],
 *   { queryKey: ["v2"] }
 * )
 */
export declare function createSuspenseInfiniteQueryFactory<A, T extends TransformKey, M extends FunctionName<A> = FunctionName<A>, TPageParam = unknown, TSelected = InfiniteData<SuspenseInfiniteQueryPageData<A, M, T>, TPageParam>>(reactor: Reactor<A, T>, config: SuspenseInfiniteQueryFactoryConfig<NoInfer<A>, M, T, TPageParam, TSelected>): SuspenseInfiniteQueryFactoryFn<A, M, T, TPageParam, TSelected>;
export {};
//# sourceMappingURL=createSuspenseInfiniteQuery.d.ts.map