@echojs-ecosystem/query 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,822 @@
+import * as _echojs_ecosystem_reactivity from '@echojs-ecosystem/reactivity';
+import { ReadonlySignal } from '@echojs-ecosystem/reactivity';
+
+type Listener<TEvent> = (event: TEvent) => void;
+declare class Subscribable<TEvent> {
+    protected listeners: Set<Listener<TEvent>>;
+    subscribe(listener: Listener<TEvent>): () => void;
+    protected notify(event: TEvent): void;
+    hasListeners(): boolean;
+}
+
+type AbortInput$1 = AbortController | AbortSignal | (() => AbortController | AbortSignal);
+type FetchAbortSource = {
+    abortController?: AbortInput$1;
+    signal?: AbortInput$1;
+};
+type FetchAbortHandle = {
+    readonly controller: AbortController;
+    readonly signal: AbortSignal;
+    /** `false` when user passed their own AbortController */
+    readonly ownsController: boolean;
+    abort(reason?: unknown): void;
+    dispose(): void;
+};
+type CancelOptions$2 = {
+    silent?: boolean;
+    reason?: unknown;
+};
+declare const resolveAbortInput: (input?: AbortInput$1) => AbortController | AbortSignal | undefined;
+declare const abortWithReason: (controller: AbortController | undefined, reason?: unknown) => void;
+declare const mergeFetchAbortSource: (...sources: (FetchAbortSource | undefined)[]) => FetchAbortSource;
+/** Creates the effective AbortController/signal for one fetch or mutation run. */
+declare const createFetchAbortHandle: (source?: FetchAbortSource) => FetchAbortHandle;
+
+type InfiniteQueryState<TPage, TPageParam, TError> = {
+    data: InfiniteQueryData<TPage, TPageParam> | undefined;
+    error: TError | null;
+    status: QueryStatus;
+    fetchStatus: QueryFetchStatus;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    fetchFailureCount: number;
+    isInvalidated: boolean;
+    hadSuccess: boolean;
+    fetchingNextPage: boolean;
+    fetchingPreviousPage: boolean;
+};
+
+declare class Removable {
+    protected gcTimeoutId: ReturnType<typeof setTimeout> | undefined;
+    protected gcTimeMs: number;
+    protected scheduleGc(onRemove: () => void): void;
+    protected clearGcTimeout(): void;
+    updateGcTime(cacheTimeMs: number): void;
+}
+
+type InfiniteQueryObserverLike = {
+    onInfiniteQueryUpdate(): void;
+};
+type InfiniteQueryConfig<TPage, TParams = void, TPageParam = unknown, TError = unknown> = {
+    client: QueryClient$1;
+    cache: InfiniteQueryCache;
+    definition: InfiniteQueryDefinition<TPage, TParams, TPageParam, TError>;
+    params: TParams;
+    queryKey: QueryKey;
+    options: ResolvedInfiniteInstanceOptions<TPage, TParams, TPageParam, TError>;
+};
+declare const hasInfiniteNextPage: <TPage, TPageParam>(data: InfiniteQueryData<TPage, TPageParam> | undefined, getNextPageParam: (lastPage: TPage, allPages: TPage[]) => TPageParam | undefined | null) => boolean;
+declare const hasInfinitePreviousPage: <TPage, TPageParam>(data: InfiniteQueryData<TPage, TPageParam> | undefined, getPreviousPageParam: ((firstPage: TPage, allPages: TPage[]) => TPageParam | undefined | null) | undefined) => boolean;
+declare class InfiniteQuery<TPage, TParams = void, TPageParam = unknown, TError = unknown> extends Removable {
+    #private;
+    readonly queryKey: QueryKey;
+    readonly queryHash: string;
+    readonly definition: InfiniteQueryDefinition<TPage, TParams, TPageParam, TError>;
+    readonly client: QueryClient$1;
+    params: TParams;
+    options: ResolvedInfiniteInstanceOptions<TPage, TParams, TPageParam, TError>;
+    state: InfiniteQueryState<TPage, TPageParam, TError>;
+    observers: Set<InfiniteQueryObserverLike>;
+    readonly $data: _echojs_ecosystem_reactivity.Signal<InfiniteQueryData<TPage, TPageParam> | undefined>;
+    readonly $error: _echojs_ecosystem_reactivity.Signal<TError | null>;
+    readonly $status: _echojs_ecosystem_reactivity.Signal<QueryStatus>;
+    readonly $fetchStatus: _echojs_ecosystem_reactivity.Signal<QueryFetchStatus>;
+    readonly $pendingCount: _echojs_ecosystem_reactivity.Signal<number>;
+    readonly $updatedAt: _echojs_ecosystem_reactivity.Signal<number | null>;
+    readonly $isInvalidated: _echojs_ecosystem_reactivity.Signal<boolean>;
+    readonly $fetchingNextPage: _echojs_ecosystem_reactivity.Signal<boolean>;
+    readonly $fetchingPreviousPage: _echojs_ecosystem_reactivity.Signal<boolean>;
+    constructor(config: InfiniteQueryConfig<TPage, TParams, TPageParam, TError>);
+    isActive(): boolean;
+    isStale(): boolean;
+    hasData(): boolean;
+    hasNextPage(): boolean;
+    hasPreviousPage(): boolean;
+    addObserver(observer: InfiniteQueryObserverLike): void;
+    removeObserver(observer: InfiniteQueryObserverLike): void;
+    reset(): void;
+    getAbortController(): AbortController | undefined;
+    getAbortSignal(): AbortSignal | undefined;
+    cancel(options?: CancelOptions$2): Promise<void>;
+    refetch(options?: RefetchOptions): Promise<InfiniteQueryData<TPage, TPageParam>>;
+    fetchNextPage(options?: FetchAbortSource): Promise<TPage | null>;
+    fetchPreviousPage(options?: FetchAbortSource): Promise<TPage | null>;
+    fetchPage(direction: InfiniteQueryFetchDirection, abortSource?: FetchAbortSource): Promise<TPage | null>;
+    onFocus(): void;
+    onOnline(): void;
+    private syncSignals;
+}
+
+type QueryFilters = {
+    exact?: boolean;
+    queryKey?: QueryKey;
+    stale?: boolean;
+    fetchStatus?: QueryFetchStatus;
+    status?: QueryStatus;
+    predicate?: (query: QueryLike) => boolean;
+};
+type QueryLike = {
+    queryKey: QueryKey;
+    queryHash: string;
+    isStale(): boolean;
+    isActive(): boolean;
+    state: {
+        fetchStatus: QueryFetchStatus;
+        status: QueryStatus;
+    };
+};
+/** TanStack Query matchQuery — filter queries in cache. */
+declare const matchQuery: (filters: QueryFilters, query: QueryLike) => boolean;
+
+declare class InfiniteQueryCache extends Subscribable<InfiniteQueryCacheEvent> {
+    #private;
+    get(queryHash: string): InfiniteQuery<unknown, void, unknown, unknown> | undefined;
+    getByKey(queryKey: QueryKey): InfiniteQuery<unknown, void, unknown, unknown> | undefined;
+    getAll(): InfiniteQuery<unknown, void, unknown, unknown>[];
+    build<TPage, TParams = void, TPageParam = unknown, TError = unknown>(config: InfiniteQueryConfig<TPage, TParams, TPageParam, TError>): InfiniteQuery<TPage, TParams, TPageParam, TError>;
+    add<TPage, TParams = void, TPageParam = unknown, TError = unknown>(query: InfiniteQuery<TPage, TParams, TPageParam, TError>): void;
+    remove<TPage, TParams = void, TPageParam = unknown, TError = unknown>(query: InfiniteQuery<TPage, TParams, TPageParam, TError>): void;
+    find(filters: QueryFilters): InfiniteQuery<unknown, void, unknown, unknown> | undefined;
+    findAll(filter?: QueryFilter): InfiniteQuery<unknown, void, unknown, unknown>[];
+    clear(): void;
+    emit(event: InfiniteQueryCacheEvent): void;
+    onFocus(): void;
+    onOnline(): void;
+}
+
+type QueryState<Data, Error> = {
+    data: Data | undefined;
+    error: Error | null;
+    status: QueryStatus;
+    fetchStatus: QueryFetchStatus;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    fetchFailureCount: number;
+    isInvalidated: boolean;
+    hadSuccess: boolean;
+};
+
+type QueryObserverLike = {
+    onQueryUpdate(): void;
+};
+type QueryConfig<TData, TParams = void, TError = unknown, TQueryData = TData> = {
+    client: QueryClient$1;
+    cache: QueryCache;
+    definition: QueryDefinition<TData, TParams, TError, TQueryData>;
+    params: TParams;
+    queryKey: QueryKey;
+    options: ResolvedInstanceOptions<TData, TParams, TError>;
+};
+declare class Query<TData, TParams = void, TError = unknown, TQueryData = TData> extends Removable {
+    #private;
+    readonly queryKey: QueryKey;
+    readonly queryHash: string;
+    readonly definition: QueryDefinition<TData, TParams, TError, TQueryData>;
+    readonly client: QueryClient$1;
+    params: TParams;
+    options: ResolvedInstanceOptions<TData, TParams, TError>;
+    state: QueryState<TData, TError>;
+    observers: Set<QueryObserverLike>;
+    readonly $data: _echojs_ecosystem_reactivity.Signal<TData | undefined>;
+    readonly $error: _echojs_ecosystem_reactivity.Signal<TError | null>;
+    readonly $status: _echojs_ecosystem_reactivity.Signal<QueryStatus>;
+    readonly $fetchStatus: _echojs_ecosystem_reactivity.Signal<QueryFetchStatus>;
+    readonly $pendingCount: _echojs_ecosystem_reactivity.Signal<number>;
+    readonly $updatedAt: _echojs_ecosystem_reactivity.Signal<number | null>;
+    readonly $isInvalidated: _echojs_ecosystem_reactivity.Signal<boolean>;
+    constructor(config: QueryConfig<TData, TParams, TError, TQueryData>);
+    get promise(): Promise<TData> | undefined;
+    isActive(): boolean;
+    isStale(): boolean;
+    isStaleByTime(staleTimeMs?: number): boolean;
+    hasData(): boolean;
+    addObserver(observer: QueryObserverLike): void;
+    removeObserver(observer: QueryObserverLike): void;
+    setData(updater: TData | ((prev: TData | undefined) => TData | undefined)): TData | undefined;
+    invalidate(): void;
+    getAbortController(): AbortController | undefined;
+    getAbortSignal(): AbortSignal | undefined;
+    cancel(options?: CancelOptions$2): Promise<void>;
+    fetch(options?: {
+        cancelRefetch?: boolean;
+    } & FetchAbortSource): Promise<TData>;
+    onFocus(): void;
+    onOnline(): void;
+    private syncSignals;
+}
+
+declare class QueryCache extends Subscribable<QueryCacheEvent> {
+    #private;
+    get(queryHash: string): Query<unknown, void, unknown> | undefined;
+    getByKey(queryKey: QueryKey): Query<unknown, void, unknown> | undefined;
+    getAll(): Query<unknown, void, unknown>[];
+    build<TData, TParams = void, TError = unknown, TQueryData = TData>(config: QueryConfig<TData, TParams, TError, TQueryData>): Query<TData, TParams, TError, TQueryData>;
+    add<TData, TParams = void, TError = unknown, TQueryData = TData>(query: Query<TData, TParams, TError, TQueryData>): void;
+    remove<TData, TParams = void, TError = unknown, TQueryData = TData>(query: Query<TData, TParams, TError, TQueryData>): void;
+    find(filters: QueryFilters): Query<unknown, void, unknown> | undefined;
+    findAll(filter?: QueryFilter): Query<unknown, void, unknown>[];
+    clear(): void;
+    emit(event: QueryCacheEvent): void;
+    onFocus(): void;
+    onOnline(): void;
+}
+
+declare class MutationCache extends Subscribable<MutationCacheEvent> {
+    emit(event: MutationCacheEvent): void;
+    clear(): void;
+}
+
+type QueryKey = readonly unknown[];
+type AbortInput = AbortController | AbortSignal | (() => AbortController | AbortSignal);
+/** Per-fetch / per-run abort wiring — external controller, external signal, or auto (default). */
+type AbortControlOptions = {
+    /** User-owned controller — `cancel()` / `abort()` also call `.abort()` on it */
+    abortController?: AbortInput;
+    /** External signal — when it aborts, the in-flight operation stops */
+    signal?: AbortInput;
+};
+type CancelOptions$1 = {
+    silent?: boolean;
+    reason?: unknown;
+};
+type FetchPageOptions = AbortControlOptions;
+type MutationRunOptions = AbortControlOptions;
+type AbortCapable = {
+    /** Current in-flight AbortController, if any */
+    abortController(): AbortController | null;
+    /** Current in-flight AbortSignal, if any */
+    abortSignal(): AbortSignal | null;
+    /** Abort the in-flight operation (alias for cancel with reason) */
+    abort(reason?: unknown): void;
+};
+type QueryStatus = 'idle' | 'pending' | 'success' | 'error';
+type QueryFetchStatus = 'idle' | 'fetching' | 'paused';
+type MutationStatus = 'idle' | 'pending' | 'success' | 'error';
+type StoreLike<Value> = {
+    value(): Value;
+    subscribe(listener: (value: Value, prevValue: Value) => void): () => void;
+};
+type QueryClientConfig = {
+    defaultOptions?: {
+        queries?: Partial<QueryOptions<unknown, void>>;
+        mutations?: Partial<MutationOptions<unknown, unknown>>;
+    };
+};
+/**
+ * Query generics:
+ * - `TData` — тип данных в кэше / instance (после `transform`)
+ * - `TParams` — параметры запроса (аргумент `queryKey` / `.with()`)
+ * - `TError` — тип ошибки
+ * - `TQueryData` — сырой ответ `queryFn` (до `transform`, по умолчанию = `TData`)
+ */
+type QueryFnContext<TParams, TQueryData, TError = unknown> = {
+    params: TParams;
+    signal: AbortSignal;
+    abortController: AbortController;
+    queryClient: QueryClient$1;
+    queryKey: QueryKey;
+};
+type QueryLifecycleContext<TData, TParams, TError = unknown> = {
+    data?: TData;
+    error?: TError | null;
+    params: TParams;
+    queryKey: QueryKey;
+    queryClient: QueryClient$1;
+};
+type QueryOptions<TData, TParams = void, TError = unknown, TQueryData = TData> = {
+    name?: string;
+    queryKey: (params: TParams) => QueryKey;
+    queryFn: (ctx: QueryFnContext<TParams, TQueryData, TError>) => Promise<TQueryData>;
+    transform?: (data: TQueryData) => TData | Promise<TData>;
+    staleTime?: number;
+    cacheTime?: number;
+    retry?: number | false | ((failureCount: number, error: unknown) => boolean);
+    retryDelay?: number | ((failureCount: number, error: unknown) => number);
+    keepPreviousData?: boolean;
+    abortPrevious?: boolean;
+    abortController?: AbortInput;
+    signal?: AbortInput;
+    enabled?: boolean | (() => boolean);
+    refetchOnMount?: boolean | 'stale';
+    refetchOnWindowFocus?: boolean;
+    refetchOnReconnect?: boolean;
+    onStart?: (ctx: QueryLifecycleContext<TData, TParams, TError>) => void;
+    onSuccess?: (ctx: QueryLifecycleContext<TData, TParams, TError>) => void;
+    onError?: (ctx: QueryLifecycleContext<TData, TParams, TError>) => void;
+    onSettled?: (ctx: QueryLifecycleContext<TData, TParams, TError>) => void;
+};
+type QueryInstanceOptions<TData = unknown, TParams = void, TError = unknown> = {
+    client?: QueryClient$1;
+    enabled?: boolean | (() => boolean);
+    refetchOnMount?: boolean | 'stale';
+    refetchOnWindowFocus?: boolean;
+    refetchOnReconnect?: boolean;
+    keepPreviousData?: boolean;
+    abortPrevious?: boolean;
+    abortController?: AbortInput;
+    signal?: AbortInput;
+    staleTime?: number;
+    cacheTime?: number;
+    retry?: number | false | ((failureCount: number, error: unknown) => boolean);
+    retryDelay?: number | ((failureCount: number, error: unknown) => number);
+    onStart?: (ctx: QueryLifecycleContext<TData, TParams, TError>) => void;
+    onSuccess?: (ctx: QueryLifecycleContext<TData, TParams, TError>) => void;
+    onError?: (ctx: QueryLifecycleContext<TData, TParams, TError>) => void;
+    onSettled?: (ctx: QueryLifecycleContext<TData, TParams, TError>) => void;
+};
+type RefetchOptions = {
+    throwOnError?: boolean;
+} & AbortControlOptions;
+type InvalidateQueriesOptions = {
+    exact?: boolean;
+    /** Default: `'active'` — refetch only queries with observers */
+    refetch?: boolean | 'active' | 'all' | 'none';
+};
+type QueryDefinition<TData, TParams = void, TError = unknown, TQueryData = TData> = {
+    readonly kind: 'query-definition';
+    readonly name?: string;
+    readonly options: QueryOptions<TData, TParams, TError, TQueryData>;
+    queryKey(params: TParams): QueryKey;
+    with(params: TParams | (() => TParams), options?: QueryInstanceOptions<TData, TParams, TError>): QueryInstance<TData, TParams, TError>;
+    withStore<StoreValue>(store: StoreLike<StoreValue>, map: (value: StoreValue) => TParams, options?: QueryInstanceOptions<TData, TParams, TError>): QueryInstance<TData, TParams, TError>;
+};
+type QueryInstance<TData, TParams = void, TError = unknown> = AbortCapable & {
+    readonly kind: 'query-instance';
+    value(): TData | undefined;
+    data(): TData | undefined;
+    error(): TError | null;
+    params(): TParams;
+    status(): QueryStatus;
+    fetchStatus(): QueryFetchStatus;
+    pending(): boolean;
+    isPending(): boolean;
+    isFirstPending(): boolean;
+    isFetching(): boolean;
+    isRefetching(): boolean;
+    isSuccess(): boolean;
+    isError(): boolean;
+    isIdle(): boolean;
+    isStale(): boolean;
+    isPaused(): boolean;
+    hasData(): boolean;
+    hasError(): boolean;
+    refetch(options?: RefetchOptions): Promise<TData>;
+    invalidate(): void;
+    cancel(options?: CancelOptions$1): void;
+    remove(): void;
+    subscribe(listener: (data: TData | undefined) => void): () => void;
+    $data: ReadonlySignal<TData | undefined>;
+    $error: ReadonlySignal<TError | null>;
+    $params: ReadonlySignal<TParams>;
+    $status: ReadonlySignal<QueryStatus>;
+    $fetchStatus: ReadonlySignal<QueryFetchStatus>;
+    $pendingCount: ReadonlySignal<number>;
+    $isStale: ReadonlySignal<boolean>;
+    $updatedAt: ReadonlySignal<number | null>;
+    $abortSignal: ReadonlySignal<AbortSignal | null>;
+};
+type QueryFilter = QueryKey | {
+    queryKey: QueryKey;
+    exact?: boolean;
+};
+type InfiniteQueryData<TPage, TPageParam> = {
+    pages: TPage[];
+    pageParams: TPageParam[];
+};
+type InfiniteQueryFetchDirection = 'initial' | 'next' | 'previous';
+/**
+ * Infinite query generics:
+ * - `TPage` — одна страница ответа `queryFn`
+ * - `TPageParam` — cursor / page param для пагинации
+ * - `TParams` — параметры `.with()` / `queryKey`
+ * - `TError` — тип ошибки
+ */
+type InfiniteQueryFnContext<TParams, TPageParam, TPage, TError = unknown> = {
+    params: TParams;
+    pageParam: TPageParam;
+    signal: AbortSignal;
+    abortController: AbortController;
+    queryClient: QueryClient$1;
+    queryKey: QueryKey;
+};
+type InfiniteQueryLifecycleContext<TPage, TParams, TPageParam, TError = unknown> = {
+    data?: InfiniteQueryData<TPage, TPageParam>;
+    error?: TError | null;
+    params: TParams;
+    queryKey: QueryKey;
+    queryClient: QueryClient$1;
+};
+type InfiniteQueryOptions<TPage, TParams = void, TPageParam = unknown, TError = unknown> = {
+    name?: string;
+    queryKey: (params: TParams) => QueryKey;
+    queryFn: (ctx: InfiniteQueryFnContext<TParams, TPageParam, TPage, TError>) => Promise<TPage>;
+    initialPageParam: TPageParam;
+    getNextPageParam: (lastPage: TPage, allPages: TPage[]) => TPageParam | undefined | null;
+    getPreviousPageParam?: (firstPage: TPage, allPages: TPage[]) => TPageParam | undefined | null;
+    staleTime?: number;
+    cacheTime?: number;
+    retry?: number | false | ((failureCount: number, error: unknown) => boolean);
+    retryDelay?: number | ((failureCount: number, error: unknown) => number);
+    keepPreviousData?: boolean;
+    abortPrevious?: boolean;
+    abortController?: AbortInput;
+    signal?: AbortInput;
+    enabled?: boolean | (() => boolean);
+    refetchOnMount?: boolean | 'stale';
+    refetchOnWindowFocus?: boolean;
+    refetchOnReconnect?: boolean;
+    onStart?: (ctx: InfiniteQueryLifecycleContext<TPage, TParams, TPageParam, TError>) => void;
+    onSuccess?: (ctx: InfiniteQueryLifecycleContext<TPage, TParams, TPageParam, TError>) => void;
+    onError?: (ctx: InfiniteQueryLifecycleContext<TPage, TParams, TPageParam, TError>) => void;
+    onSettled?: (ctx: InfiniteQueryLifecycleContext<TPage, TParams, TPageParam, TError>) => void;
+};
+type InfiniteQueryInstanceOptions<TPage = unknown, TParams = void, TPageParam = unknown, TError = unknown> = {
+    client?: QueryClient$1;
+    enabled?: boolean | (() => boolean);
+    refetchOnMount?: boolean | 'stale';
+    refetchOnWindowFocus?: boolean;
+    refetchOnReconnect?: boolean;
+    keepPreviousData?: boolean;
+    abortPrevious?: boolean;
+    abortController?: AbortInput;
+    signal?: AbortInput;
+    staleTime?: number;
+    cacheTime?: number;
+    retry?: number | false | ((failureCount: number, error: unknown) => boolean);
+    retryDelay?: number | ((failureCount: number, error: unknown) => number);
+    onStart?: (ctx: InfiniteQueryLifecycleContext<TPage, TParams, TPageParam, TError>) => void;
+    onSuccess?: (ctx: InfiniteQueryLifecycleContext<TPage, TParams, TPageParam, TError>) => void;
+    onError?: (ctx: InfiniteQueryLifecycleContext<TPage, TParams, TPageParam, TError>) => void;
+    onSettled?: (ctx: InfiniteQueryLifecycleContext<TPage, TParams, TPageParam, TError>) => void;
+};
+type InfiniteQueryDefinition<TPage, TParams = void, TPageParam = unknown, TError = unknown> = {
+    readonly kind: 'infinite-query-definition';
+    readonly name?: string;
+    readonly options: InfiniteQueryOptions<TPage, TParams, TPageParam, TError>;
+    queryKey(params: TParams): QueryKey;
+    with(params: TParams | (() => TParams), options?: InfiniteQueryInstanceOptions<TPage, TParams, TPageParam, TError>): InfiniteQueryInstance<TPage, TPageParam, TParams, TError>;
+    withStore<StoreValue>(store: StoreLike<StoreValue>, map: (value: StoreValue) => TParams, options?: InfiniteQueryInstanceOptions<TPage, TParams, TPageParam, TError>): InfiniteQueryInstance<TPage, TPageParam, TParams, TError>;
+};
+type InfiniteQueryInstance<TPage, TPageParam = unknown, TParams = void, TError = unknown> = AbortCapable & {
+    readonly kind: 'infinite-query';
+    pages(): TPage[];
+    pageParams(): TPageParam[];
+    data(): InfiniteQueryData<TPage, TPageParam> | null;
+    flatMap<TItem>(selector: (page: TPage) => TItem[]): TItem[];
+    fetchNextPage(options?: FetchPageOptions): Promise<TPage | null>;
+    fetchPreviousPage(options?: FetchPageOptions): Promise<TPage | null>;
+    refetch(options?: RefetchOptions): Promise<InfiniteQueryData<TPage, TPageParam>>;
+    reset(): void;
+    cancel(options?: CancelOptions$1): void;
+    remove(): void;
+    hasNextPage(): boolean;
+    hasPreviousPage(): boolean;
+    pending(): boolean;
+    fetching(): boolean;
+    fetchingNextPage(): boolean;
+    fetchingPreviousPage(): boolean;
+    error(): TError | null;
+    params(): TParams;
+    subscribe(listener: (data: InfiniteQueryData<TPage, TPageParam> | null) => void): () => void;
+    $data: ReadonlySignal<InfiniteQueryData<TPage, TPageParam> | null>;
+    $pages: ReadonlySignal<TPage[]>;
+    $pageParams: ReadonlySignal<TPageParam[]>;
+    $pending: ReadonlySignal<boolean>;
+    $fetching: ReadonlySignal<boolean>;
+    $fetchingNextPage: ReadonlySignal<boolean>;
+    $fetchingPreviousPage: ReadonlySignal<boolean>;
+    $error: ReadonlySignal<TError | null>;
+    $params: ReadonlySignal<TParams>;
+    $abortSignal: ReadonlySignal<AbortSignal | null>;
+};
+type InfiniteQueryCacheEvent = {
+    type: 'infiniteQueryAdded';
+    queryKey: QueryKey;
+    hash: string;
+} | {
+    type: 'infiniteQueryRemoved';
+    queryKey: QueryKey;
+    hash: string;
+} | {
+    type: 'infiniteQueryUpdated';
+    queryKey: QueryKey;
+    hash: string;
+} | {
+    type: 'infiniteQueryFetched';
+    queryKey: QueryKey;
+    hash: string;
+};
+type ResolvedInfiniteInstanceOptions<TPage, TParams = void, TPageParam = unknown, TError = unknown> = InfiniteQueryInstanceOptions<TPage, TParams, TPageParam, TError> & Required<Pick<InfiniteQueryInstanceOptions<TPage, TParams, TPageParam, TError>, 'enabled' | 'refetchOnMount' | 'refetchOnWindowFocus' | 'refetchOnReconnect' | 'keepPreviousData' | 'abortPrevious'>> & {
+    staleTimeMs: number;
+    cacheTimeMs: number;
+    retry: number | false | ((failureCount: number, error: unknown) => boolean);
+    retryDelay: number | ((failureCount: number, error: unknown) => number);
+};
+/**
+ * Mutation generics:
+ * - `TData` — результат mutation
+ * - `TVariables` — входные переменные `.run()`
+ * - `TError` — тип ошибки
+ * - `TRollback` — контекст отката из `onMutate`
+ */
+type MutationFnContext<TVariables, TData, TError = unknown> = {
+    variables: TVariables;
+    signal: AbortSignal;
+    abortController: AbortController;
+    queryClient: QueryClient$1;
+};
+type MutationLifecycleContext<TData, TVariables, TError = unknown, TRollback = unknown> = {
+    data?: TData;
+    error?: TError | null;
+    variables: TVariables;
+    queryClient: QueryClient$1;
+    rollback?: TRollback;
+};
+type MutationOptions<TData, TVariables, TError = unknown, TRollback = unknown> = {
+    name?: string;
+    mutationFn: (ctx: MutationFnContext<TVariables, TData, TError>) => Promise<TData>;
+    abortController?: AbortInput;
+    signal?: AbortInput;
+    retry?: number | false | ((failureCount: number, error: unknown) => boolean);
+    retryDelay?: number | ((failureCount: number, error: unknown) => number);
+    onMutate?: (ctx: MutationLifecycleContext<TData, TVariables, TError, TRollback>) => Promise<TRollback | void> | TRollback | void;
+    onSuccess?: (ctx: MutationLifecycleContext<TData, TVariables, TError, TRollback>) => void;
+    onError?: (ctx: MutationLifecycleContext<TData, TVariables, TError, TRollback>) => void;
+    onSettled?: (ctx: MutationLifecycleContext<TData, TVariables, TError, TRollback>) => void;
+};
+type MutationDefinition<TData, TVariables, TError = unknown, TRollback = unknown> = {
+    readonly kind: 'mutation-definition';
+    readonly name?: string;
+    readonly options: MutationOptions<TData, TVariables, TError, TRollback>;
+    create(options?: {
+        client?: QueryClient$1;
+    }): MutationInstance<TData, TVariables, TError>;
+};
+type MutationInstance<TData, TVariables, TError = unknown> = AbortCapable & {
+    readonly kind: 'mutation-instance';
+    run(variables: TVariables, options?: MutationRunOptions): Promise<TData>;
+    reset(): void;
+    cancel(options?: CancelOptions$1): void;
+    data(): TData | undefined;
+    error(): TError | null;
+    variables(): TVariables | undefined;
+    status(): MutationStatus;
+    pending(): boolean;
+    isPending(): boolean;
+    isSuccess(): boolean;
+    isError(): boolean;
+    isIdle(): boolean;
+    $data: ReadonlySignal<TData | undefined>;
+    $error: ReadonlySignal<TError | null>;
+    $variables: ReadonlySignal<TVariables | undefined>;
+    $status: ReadonlySignal<MutationStatus>;
+    $pendingCount: ReadonlySignal<number>;
+    $abortSignal: ReadonlySignal<AbortSignal | null>;
+};
+type QueryCacheEvent = {
+    type: 'queryAdded';
+    queryKey: QueryKey;
+    hash: string;
+} | {
+    type: 'queryRemoved';
+    queryKey: QueryKey;
+    hash: string;
+} | {
+    type: 'queryUpdated';
+    queryKey: QueryKey;
+    hash: string;
+} | {
+    type: 'queryInvalidated';
+    queryKey: QueryKey;
+    hash: string;
+} | {
+    type: 'queryFetched';
+    queryKey: QueryKey;
+    hash: string;
+    data?: unknown;
+};
+type MutationCacheEvent = {
+    type: 'mutationAdded';
+    mutationId: number;
+} | {
+    type: 'mutationUpdated';
+    mutationId: number;
+};
+type QueryClient$1 = {
+    readonly queryCache: QueryCache;
+    readonly infiniteQueryCache: InfiniteQueryCache;
+    readonly mutationCache: MutationCache;
+    fetchQuery<TData, TParams = void, TError = unknown, TQueryData = TData>(definition: QueryDefinition<TData, TParams, TError, TQueryData>, params?: TParams, options?: QueryInstanceOptions<TData, TParams, TError>): Promise<TData>;
+    prefetchQuery<TData, TParams = void, TError = unknown, TQueryData = TData>(definition: QueryDefinition<TData, TParams, TError, TQueryData>, params?: TParams, options?: QueryInstanceOptions<TData, TParams, TError>): Promise<void>;
+    ensureQueryData<TData, TParams = void, TError = unknown, TQueryData = TData>(definition: QueryDefinition<TData, TParams, TError, TQueryData>, params?: TParams, options?: QueryInstanceOptions<TData, TParams, TError>): Promise<TData>;
+    getQueryData<TData>(keyOrDefinition: QueryKey): TData | undefined;
+    getQueryData<TData, TError = unknown, TQueryData = TData>(definition: QueryDefinition<TData, void, TError, TQueryData>): TData | undefined;
+    getQueryData<TData, TParams, TError = unknown, TQueryData = TData>(definition: QueryDefinition<TData, TParams, TError, TQueryData>, params: TParams): TData | undefined;
+    setQueryData<TData>(keyOrDefinition: QueryKey, updater: TData | ((prev: TData | undefined) => TData | undefined)): void;
+    setQueryData<TData>(definition: QueryDefinition<TData, void, unknown, unknown>, updater: TData | ((prev: TData | undefined) => TData | undefined)): void;
+    setQueryData<TData, TParams, TError = unknown, TQueryData = TData>(definition: QueryDefinition<TData, TParams, TError, TQueryData>, params: TParams, updater: TData | ((prev: TData | undefined) => TData | undefined)): void;
+    invalidateQueries(filter: QueryFilter, options?: InvalidateQueriesOptions): void;
+    refetchQueries(filter: QueryFilter): Promise<void>;
+    cancelQueries(filter: QueryFilter): void;
+    removeQueries(filter: QueryFilter): void;
+    clear(): void;
+};
+type ResolvedInstanceOptions<TData, TParams = void, TError = unknown> = QueryInstanceOptions<TData, TParams, TError> & Required<Pick<QueryInstanceOptions<TData, TParams, TError>, 'enabled' | 'refetchOnMount' | 'refetchOnWindowFocus' | 'refetchOnReconnect' | 'keepPreviousData' | 'abortPrevious'>> & {
+    staleTimeMs: number;
+    cacheTimeMs: number;
+    retry: number | false | ((failureCount: number, error: unknown) => boolean);
+    retryDelay: number | ((failureCount: number, error: unknown) => number);
+};
+
+declare class QueryClient {
+    readonly queryCache: QueryCache;
+    readonly infiniteQueryCache: InfiniteQueryCache;
+    readonly mutationCache: MutationCache;
+    constructor(config?: QueryClientConfig);
+    fetchQuery<TData, TParams = void, TError = unknown, TQueryData = TData>(definition: QueryDefinition<TData, TParams, TError, TQueryData>, params?: TParams, options?: QueryInstanceOptions<TData, TParams, TError>): Promise<TData>;
+    prefetchQuery<TData, TParams = void, TError = unknown, TQueryData = TData>(definition: QueryDefinition<TData, TParams, TError, TQueryData>, params?: TParams, options?: QueryInstanceOptions<TData, TParams, TError>): Promise<void>;
+    ensureQueryData<TData, TParams = void, TError = unknown, TQueryData = TData>(definition: QueryDefinition<TData, TParams, TError, TQueryData>, params?: TParams, options?: QueryInstanceOptions<TData, TParams, TError>): Promise<TData>;
+    getQueryData<TData>(keyOrDefinition: QueryKey): TData | undefined;
+    getQueryData<TData, TError = unknown, TQueryData = TData>(definition: QueryDefinition<TData, void, TError, TQueryData>): TData | undefined;
+    getQueryData<TData, TParams, TError = unknown, TQueryData = TData>(definition: QueryDefinition<TData, TParams, TError, TQueryData>, params: TParams): TData | undefined;
+    setQueryData<TData>(keyOrDefinition: QueryKey, updater: TData | ((prev: TData | undefined) => TData | undefined)): void;
+    setQueryData<TData>(definition: QueryDefinition<TData, void, unknown, unknown>, updater: TData | ((prev: TData | undefined) => TData | undefined)): void;
+    setQueryData<TData, TParams, TError = unknown, TQueryData = TData>(definition: QueryDefinition<TData, TParams, TError, TQueryData>, params: TParams, updater: TData | ((prev: TData | undefined) => TData | undefined)): void;
+    invalidateQueries(filter: QueryFilter, options?: InvalidateQueriesOptions): void;
+    refetchQueries(filter: QueryFilter): Promise<void>;
+    cancelQueries(filter: QueryFilter): void;
+    removeQueries(filter: QueryFilter): void;
+    clear(): void;
+}
+declare const createQueryClient: (config?: QueryClientConfig) => QueryClient;
+
+type QueryProviderDefaultOptions = {
+    queries?: Partial<Omit<QueryOptions<unknown, void>, 'queryKey' | 'queryFn'>>;
+    mutations?: Partial<Omit<MutationOptions<unknown, unknown>, 'mutationFn'>>;
+};
+type QueryProviderConfig = QueryClientConfig & {
+    client?: QueryClient$1;
+    defaultOptions?: QueryProviderDefaultOptions;
+};
+
+declare const getQueryProvider: () => QueryProvider | null;
+declare const requireQueryProvider: () => QueryProvider;
+declare const resetQueryProvider: () => void;
+
+declare class QueryProvider {
+    readonly client: QueryClient;
+    readonly config: QueryProviderConfig;
+    constructor(config?: QueryProviderConfig);
+    createQuery: <TData, TParams = void, TError = unknown, TQueryData = TData>(options: QueryOptions<TData, TParams, TError, TQueryData>) => QueryDefinition<TData, TParams, TError, TQueryData>;
+    createMutation: <TData, TVariables, TError = unknown, TRollback = unknown>(options: MutationOptions<TData, TVariables, TError, TRollback>) => MutationDefinition<TData, TVariables, TError, TRollback>;
+    createInfiniteQuery: <TPage, TParams = void, TPageParam = unknown, TError = unknown>(options: InfiniteQueryOptions<TPage, TParams, TPageParam, TError>) => InfiniteQueryDefinition<TPage, TParams, TPageParam, TError>;
+    invalidateQueries(filter: QueryFilter, options?: InvalidateQueriesOptions): void;
+    refetchQueries(filter: QueryFilter): Promise<void>;
+    cancelQueries(filter: QueryFilter): void;
+    removeQueries(filter: QueryFilter): void;
+}
+declare const setQueryProvider: (provider: QueryProvider) => void;
+
+type CreateQueryMeta = {
+    provider?: QueryProvider | null;
+};
+declare const createQuery: <TData, TParams = void, TError = unknown, TQueryData = TData>(options: QueryOptions<TData, TParams, TError, TQueryData>, meta?: CreateQueryMeta) => QueryDefinition<TData, TParams, TError, TQueryData>;
+
+type CreateInfiniteQueryMeta = {
+    provider?: QueryProvider | null;
+};
+declare const createInfiniteQuery: <TPage, TParams = void, TPageParam = unknown, TError = unknown>(options: InfiniteQueryOptions<TPage, TParams, TPageParam, TError>, meta?: CreateInfiniteQueryMeta) => InfiniteQueryDefinition<TPage, TParams, TPageParam, TError>;
+
+declare const setDefaultQueryClient: (client: QueryClient$1) => void;
+declare const getDefaultQueryClient: () => QueryClient$1;
+
+declare const QUERY_PROVIDER_KEY: unique symbol;
+/** Minimal host shape — compatible with {@link EchoApp} from `@echojs-ecosystem/framework/app`. */
+type QueryProviderHost = {
+    provide?<T>(key: symbol, value: T): unknown;
+};
+/** @deprecated Use {@link QueryProviderHost} */
+type QueryPluginHost = QueryProviderHost;
+/** Echo app provider with the active {@link QueryProvider} instance. */
+type EchoQueryProvider = {
+    name: 'query';
+    readonly provider: QueryProvider;
+    setup: (app: QueryProviderHost) => void;
+};
+/** @deprecated Use {@link EchoQueryProvider} */
+type EchoQueryPlugin = EchoQueryProvider;
+/** @deprecated Use {@link EchoQueryProvider} */
+type QueryPlugin = EchoQueryProvider;
+/**
+ * Creates a query provider: registers the global provider on call and exposes it on `app.use`.
+ *
+ * ```ts
+ * export const queryProvider = createQueryProvider({
+ *   defaultOptions: { queries: { staleTime: 60_000 } },
+ * });
+ * ```
+ */
+declare const createQueryProvider: (config?: QueryProviderConfig) => EchoQueryProvider;
+/** @deprecated Use {@link createQueryProvider} */
+declare const createQueryPlugin: (config?: QueryProviderConfig) => EchoQueryProvider;
+/** @deprecated Use {@link createQueryProvider} */
+declare const queryPlugin: (config?: QueryProviderConfig) => EchoQueryProvider;
+
+declare const createMutation: <TData, TVariables, TError = unknown, TRollback = unknown>(options: MutationOptions<TData, TVariables, TError, TRollback>, meta?: CreateQueryMeta) => MutationDefinition<TData, TVariables, TError, TRollback>;
+
+declare class FocusManager {
+    #private;
+    constructor();
+    isFocused(): boolean;
+    setFocused(focused: boolean): void;
+    subscribe(listener: (focused: boolean) => void): () => void;
+    onClientRegistered(client: QueryClient$1): void;
+}
+declare const focusManager: FocusManager;
+
+declare class OnlineManager {
+    #private;
+    constructor();
+    isOnline(): boolean;
+    setOnline(online: boolean): void;
+    subscribe(listener: (online: boolean) => void): () => void;
+    onClientRegistered(client: QueryClient$1): void;
+}
+declare const onlineManager: OnlineManager;
+
+declare class Mutation<TData, TVariables, TError = unknown, TRollback = unknown> {
+    #private;
+    readonly id: number;
+    readonly definition: MutationDefinition<TData, TVariables, TError, TRollback>;
+    readonly client: QueryClient$1;
+    readonly cache: MutationCache;
+    readonly $data: _echojs_ecosystem_reactivity.Signal<TData | undefined>;
+    readonly $error: _echojs_ecosystem_reactivity.Signal<TError | null>;
+    readonly $variables: _echojs_ecosystem_reactivity.Signal<TVariables | undefined>;
+    readonly $status: _echojs_ecosystem_reactivity.Signal<MutationStatus>;
+    readonly $pendingCount: _echojs_ecosystem_reactivity.Signal<number>;
+    constructor(definition: MutationDefinition<TData, TVariables, TError, TRollback>, client: QueryClient$1, cache: MutationCache);
+    getAbortController(): AbortController | undefined;
+    getAbortSignal(): AbortSignal | undefined;
+    run(variables: TVariables, runOptions?: MutationRunOptions): Promise<TData>;
+    cancel(options?: CancelOptions$2): void;
+    reset(): void;
+    toInstance(): MutationInstance<TData, TVariables, TError>;
+}
+
+declare class QueryObserver<TData, TParams = void, TError = unknown, TQueryData = TData> {
+    #private;
+    readonly definition: QueryDefinition<TData, TParams, TError, TQueryData>;
+    readonly client: QueryClient$1;
+    readonly options: ResolvedInstanceOptions<TData, TParams, TError>;
+    constructor(definition: QueryDefinition<TData, TParams, TError, TQueryData>, client: QueryClient$1, params: TParams | (() => TParams), instanceOptions?: QueryInstanceOptions<TData, TParams, TError>);
+    getQuery(): Query<TData, TParams, TError, TQueryData> | null;
+    getPreviousQuery(): Query<TData, TParams, TError, TQueryData> | null;
+    getParams(): TParams;
+    onQueryUpdate(): void;
+    subscribe(listener: () => void): () => void;
+    setParams(params: TParams): void;
+    maybeFetch(paramsChanged: boolean): void;
+    fetch(options?: RefetchOptions): Promise<TData>;
+    refetch(options?: RefetchOptions): Promise<TData>;
+    invalidate(): void;
+    cancel(options?: CancelOptions$1): Promise<void>;
+    remove(): void;
+    destroy(): void;
+}
+
+declare class InfiniteQueryObserver<TPage, TParams = void, TPageParam = unknown, TError = unknown> {
+    #private;
+    readonly definition: InfiniteQueryDefinition<TPage, TParams, TPageParam, TError>;
+    readonly client: QueryClient$1;
+    readonly options: ResolvedInfiniteInstanceOptions<TPage, TParams, TPageParam, TError>;
+    constructor(definition: InfiniteQueryDefinition<TPage, TParams, TPageParam, TError>, client: QueryClient$1, params: TParams | (() => TParams), instanceOptions?: InfiniteQueryInstanceOptions<TPage, TParams, TPageParam, TError>);
+    getQuery(): InfiniteQuery<TPage, TParams, TPageParam, TError> | null;
+    getPreviousQuery(): InfiniteQuery<TPage, TParams, TPageParam, TError> | null;
+    getParams(): TParams;
+    onInfiniteQueryUpdate(): void;
+    subscribe(listener: () => void): () => void;
+    setParams(params: TParams): void;
+    maybeFetch(paramsChanged: boolean): void;
+    cancel(options?: CancelOptions$1): void;
+    remove(): void;
+    destroy(): void;
+}
+
+/** TanStack Query stable hash — sorts object keys recursively. */
+declare const hashKey: (queryKey: QueryKey) => string;
+/** TanStack Query partial key match. */
+declare const partialMatchKey: (a: QueryKey, b: QueryKey) => boolean;
+
+type CancelOptions = {
+    revert?: boolean;
+    silent?: boolean;
+};
+declare class CancelledError extends Error {
+    readonly revert?: boolean;
+    readonly silent?: boolean;
+    constructor(options?: CancelOptions);
+}
+declare const isCancelledError: (value: unknown) => value is CancelledError;
+
+export { type AbortCapable, type AbortControlOptions, type AbortInput, type CancelOptions$1 as CancelOptions, CancelledError, type EchoQueryPlugin, type EchoQueryProvider, type FetchPageOptions, FocusManager, InfiniteQuery, InfiniteQueryCache, type InfiniteQueryData, type InfiniteQueryDefinition, type InfiniteQueryFnContext, type InfiniteQueryInstance, type InfiniteQueryInstanceOptions, InfiniteQueryObserver, type InfiniteQueryOptions, type InvalidateQueriesOptions, Mutation, MutationCache, type MutationDefinition, type MutationFnContext, type MutationInstance, type MutationOptions, type MutationRunOptions, type MutationStatus, OnlineManager, QUERY_PROVIDER_KEY, Query, QueryCache, QueryClient, type QueryClientConfig, type QueryDefinition, type QueryFetchStatus, type QueryFilter, type QueryFnContext, type QueryInstance, type QueryInstanceOptions, type QueryKey, QueryObserver, type QueryOptions, type QueryPlugin, type QueryPluginHost, QueryProvider, type QueryProviderConfig, type QueryProviderDefaultOptions, type QueryProviderHost, type QueryStatus, type RefetchOptions, type StoreLike, abortWithReason, createFetchAbortHandle, createInfiniteQuery, createMutation, createQuery, createQueryClient, createQueryPlugin, createQueryProvider, focusManager, getDefaultQueryClient, getQueryProvider, hasInfiniteNextPage, hasInfinitePreviousPage, hashKey, isCancelledError, matchQuery, mergeFetchAbortSource, onlineManager, partialMatchKey, queryPlugin, requireQueryProvider, resetQueryProvider, resolveAbortInput, setDefaultQueryClient, setQueryProvider };