@duongtrungnguyen/next-helper/dist/types/query/types.d.ts

Helper library for Next.js 15

export type QueryKey = readonly unknown[];
export type QueryFunction<TData = unknown, TParams = unknown> = (params: TParams, context: QueryFunctionContext) => Promise<TData>;
export type QueryFunctionContext = {
    queryKey: QueryKey;
    signal?: AbortSignal;
};
export type QueryOptions<TData = unknown, TParams = unknown> = {
    queryKey: QueryKey;
    queryFn: QueryFunction<TData, TParams>;
    enabled?: boolean;
    staleTime?: number;
    cacheTime?: number;
    retry?: boolean | number;
    retryDelay?: number | ((attempt: number) => number);
    onSuccess?: (data: TData) => void;
    onError?: (error: Error) => void;
    onSettled?: (data: TData | undefined, error: Error | null) => void;
    initialData?: TData | (() => TData | undefined);
    refetchInterval?: number | false;
    refetchOnWindowFocus?: boolean;
    refetchOnMount?: boolean;
    refetchOnReconnect?: boolean;
    select?: (data: TData) => TData;
};
export type QueryResult<TData = unknown> = {
    data: TData | undefined;
    error: Error | null;
    isLoading: boolean;
    isError: boolean;
    isSuccess: boolean;
    isFetching: boolean;
    refetch: () => Promise<TData>;
    status: "idle" | "loading" | "error" | "success";
};
export type MutationOptions<TData = unknown, TVariables = unknown> = {
    mutationFn: (variables: TVariables) => Promise<TData>;
    onMutate?: (variables: TVariables) => Promise<unknown> | unknown;
    onSuccess?: (data: TData, variables: TVariables, context: unknown) => Promise<void> | void;
    onError?: (error: Error, variables: TVariables, context: unknown) => Promise<void> | void;
    onSettled?: (data: TData | undefined, error: Error | null, variables: TVariables, context: unknown) => Promise<void> | void;
    retry?: boolean | number;
    retryDelay?: number | ((attempt: number) => number);
};
export type MutationResult<TData = unknown, TVariables = unknown> = {
    data: TData | undefined;
    error: Error | null;
    isLoading: boolean;
    isError: boolean;
    isSuccess: boolean;
    isIdle: boolean;
    reset: () => void;
    mutate: (variables: TVariables) => Promise<TData>;
    mutateAsync: (variables: TVariables) => Promise<TData>;
    status: "idle" | "loading" | "error" | "success";
};
export type QueryClient = {
    getQueryData: <TData>(queryKey: QueryKey) => TData | undefined;
    setQueryData: <TData>(queryKey: QueryKey, data: TData | ((oldData: TData | undefined) => TData)) => void;
    invalidateQueries: (queryKey: QueryKey) => Promise<void>;
    refetchQueries: (queryKey: QueryKey) => Promise<void>;
    removeQueries: (queryKey: QueryKey) => void;
    clear: () => void;
    isFetching: () => number;
};
export type InfiniteQueryOptions<TData = unknown, TParams = unknown> = Omit<QueryOptions<TData[], TParams>, "queryFn"> & {
    queryFn: (params: TParams & {
        pageParam: number;
    }, context?: QueryFunctionContext) => Promise<TData[]>;
    getNextPageParam: (lastPage: TData[], allPages: TData[][]) => number | undefined;
    getPreviousPageParam?: (firstPage: TData[], allPages: TData[][]) => number | undefined;
    initialPageParam?: number;
};
export type InfiniteQueryResult<TData = unknown> = Omit<QueryResult<TData[][]>, "data" | "refetch"> & {
    data: TData[][] | undefined;
    fetchNextPage: () => Promise<TData[][]>;
    fetchPreviousPage: () => Promise<TData[][]>;
    hasNextPage: boolean;
    hasPreviousPage: boolean;
    isFetchingNextPage: boolean;
    isFetchingPreviousPage: boolean;
    refetch: () => Promise<TData[][]>;
};
export type PaginationOptions = {
    pageSize?: number;
    pageIndex?: number;
    totalCount?: number;
};
export type PaginatedQueryOptions<TData = unknown, TParams = unknown> = Omit<QueryOptions<{
    data: TData[];
    totalCount: number;
    pageCount: number;
}, TParams>, "queryFn"> & {
    queryFn: (params: TParams & {
        pagination: PaginationOptions;
    }, context?: QueryFunctionContext) => Promise<{
        data: TData[];
        totalCount: number;
        pageCount: number;
    }>;
    pageSize?: number;
    pageIndex?: number;
    keepPreviousData?: boolean;
};
export type PaginatedQueryResult<TData = unknown> = Omit<QueryResult<{
    data: TData[];
    totalCount: number;
    pageCount: number;
}>, "data"> & {
    data: TData[] | undefined;
    totalCount: number;
    pageCount: number;
    pageIndex: number;
    pageSize: number;
    setPageIndex: (index: number) => void;
    previousPage: () => void;
    nextPage: () => void;
    canPreviousPage: boolean;
    canNextPage: boolean;
};
export type QueryFnFromUrl<TData = unknown> = (url: string, params?: Record<string, any>) => Promise<TData>;
//# sourceMappingURL=types.d.ts.map