@vef-framework-react/core 2.1.0

package/dist/types/src/common/types.d.ts

@@ -0,0 +1,98 @@
+import { AnyObject, EmptyObject, Except, Key } from '@vef-framework-react/shared';
+/**
+ * Pagination parameters for list queries.
+ * Used to specify which page and how many items per page to retrieve.
+ */
+export interface PaginationParams {
+    /**
+     * The page number, starting from 1
+     *
+     * @default 1
+     */
+    page?: number;
+    /**
+     * The number of items per page
+     *
+     * @default 15
+     */
+    size?: number;
+}
+/**
+ * Pagination result wrapper for paginated list responses.
+ * Contains the items for the current page and the total count across all pages.
+ *
+ * @template T - The type of items in the paginated list
+ */
+export interface PaginationResult<T = unknown> {
+    /**
+     * Total number of items across all pages
+     */
+    readonly total: number;
+    /**
+     * Items in the current page
+     */
+    readonly items: T[];
+}
+/**
+ * Base data option type for select, tree-select, cascader and other data-driven components.
+ *
+ * @template T - Additional custom fields that can be merged into the option
+ * @template M - Type of the metadata field
+ */
+export type DataOption<T = EmptyObject, M extends AnyObject = AnyObject> = T & {
+    /**
+     * Display text of the option
+     */
+    label: string;
+    /**
+     * Unique identifier of the option
+     */
+    value: Key;
+    /**
+     * Whether the option is disabled
+     *
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Additional description or help text for the option
+     */
+    description?: string;
+    /**
+     * Additional metadata for the option
+     */
+    meta?: M;
+    /**
+     * Child options for tree-like structures (e.g., TreeSelect, Cascader)
+     */
+    children?: Array<DataOption<T, M>>;
+};
+/**
+ * Data option with pinyin fields for Chinese character search and sorting.
+ * Extends {@link DataOption} with pinyin support to enable fuzzy search by pronunciation.
+ *
+ * @template T - Additional custom fields that can be merged into the option
+ * @template M - Type of the metadata field
+ */
+export type DataOptionWithPinyin<T = EmptyObject, M extends AnyObject = AnyObject> = Except<DataOption<T, M>, "children"> & {
+    /**
+     * Pinyin representation of the label
+     */
+    labelPinyin: string;
+    /**
+     * Initials of the pinyin representation of the label
+     */
+    labelPinyinInitials: string;
+    /**
+     * Pinyin representation of the description
+     */
+    descriptionPinyin?: string;
+    /**
+     * Initials of the pinyin representation of the description
+     */
+    descriptionPinyinInitials?: string;
+    /**
+     * Child options with pinyin support
+     */
+    children?: Array<DataOptionWithPinyin<T, M>>;
+};

package/dist/types/src/context/api-client.d.ts

@@ -0,0 +1,17 @@
+import { PropsWithChildren } from 'react';
+import { ApiClient } from '../api';
+interface ApiClientProviderProps extends PropsWithChildren {
+    value: ApiClient;
+}
+/**
+ * Provider for the API client context.
+ * Wraps children with both ApiClient context and React Query's QueryClientProvider.
+ */
+export declare function ApiClientProvider({ value, children }: ApiClientProviderProps): React.JSX.Element;
+/**
+ * Hook to access the API client from context.
+ *
+ * @throws Error if used outside of ApiClientProvider.
+ */
+export declare function useApiClient(): ApiClient;
+export {};

package/dist/types/src/context/app.d.ts

@@ -0,0 +1,12 @@
+import { AppContext } from './types';
+import { Context, Provider } from 'react';
+declare const AppContext: Context<AppContext>;
+/**
+ * Provider for the VEF app context.
+ */
+export declare const AppContextProvider: Provider<AppContext>;
+/**
+ * Hook to access the VEF app context.
+ */
+export declare function useAppContext(): AppContext;
+export {};

package/dist/types/src/context/context-selector.d.ts

@@ -0,0 +1,32 @@
+import { ComponentType, PropsWithChildren } from 'react';
+/**
+ * Props for the selector context provider component.
+ */
+export interface SelectorContextProviderProps<TValue> extends PropsWithChildren {
+    value: TValue;
+}
+/**
+ * Context hook interface with optional selector support.
+ */
+export interface UseSelectorContext<in out TValue> {
+    /**
+     * Returns the full context value.
+     */
+    <TStrictValue extends TValue = TValue>(): TStrictValue;
+    /**
+     * Returns the selected portion of the context value.
+     */
+    <TStrictValue extends TValue = TValue, TSelected = TStrictValue>(selector: (value: TStrictValue) => TSelected): NoInfer<TSelected>;
+}
+/**
+ * Result of creating a selector context.
+ */
+export interface SelectorContextResult<TValue> {
+    Provider: ComponentType<SelectorContextProviderProps<TValue>>;
+    useContext: UseSelectorContext<TValue>;
+}
+/**
+ * Creates a context with selector support for optimal re-rendering.
+ * Consuming components can select specific parts of the context value.
+ */
+export declare function createContextWithSelector<TValue>(defaultValue: TValue): SelectorContextResult<TValue>;

package/dist/types/src/context/disabled.d.ts

@@ -0,0 +1,9 @@
+import { Provider } from 'react';
+/**
+ * Hook to access the disabled state from context.
+ */
+export declare function useDisabled(): boolean;
+/**
+ * Provider for the disabled state context.
+ */
+export declare const DisabledProvider: Provider<boolean>;

package/dist/types/src/context/index.d.ts

@@ -0,0 +1,6 @@
+export { ApiClientProvider, useApiClient } from './api-client';
+export { AppContextProvider, useAppContext } from './app';
+export type { SelectorContextProviderProps, SelectorContextResult, UseSelectorContext } from './context-selector';
+export { createContextWithSelector } from './context-selector';
+export { DisabledProvider, useDisabled } from './disabled';
+export type { AppContext } from './types';

package/dist/types/src/context/types.d.ts

@@ -0,0 +1,26 @@
+import { QueryFunction } from '../api';
+import { DataOption } from '../common';
+/**
+ * The context of the vef app.
+ */
+export interface AppContext {
+    /**
+     * Whether the user is authorized to access the resource identified by the token.
+     *
+     * @example
+     * ```ts
+     * const isAuthorized = hasPermission("user:query");
+     * ```
+     * @param token - The permission token.
+     * @returns Whether the user has the permission to access the resource identified by the token.
+     */
+    hasPermission?: (token: string) => boolean;
+    /**
+     * The query function for the data dictionary.
+     */
+    dataDictQueryFn?: QueryFunction<DataOption[], string>;
+    /**
+     * The base URL for file access.
+     */
+    fileBaseUrl?: string;
+}

package/dist/types/src/dnd/index.d.ts

@@ -0,0 +1,8 @@
+export { AxisModifier, restrictShapeToBoundingRectangle, RestrictToHorizontalAxis, RestrictToVerticalAxis, SnapModifier } from '@dnd-kit/abstract/modifiers';
+export { RestrictToElement, RestrictToWindow } from '@dnd-kit/dom/modifiers';
+export { arrayMove as moveArrayItem, move as moveDragItem, arraySwap as swapArrayItem, swap as swapDragItem } from '@dnd-kit/helpers';
+export type { DragDropEventHandlers, DragDropEvents } from '@dnd-kit/react';
+export { DragDropProvider, DragOverlay, KeyboardSensor, PointerSensor, useDragDropMonitor, useDraggable, useDroppable } from '@dnd-kit/react';
+export { useSortable } from '@dnd-kit/react/sortable';
+export type { DragDropContextProps, DraggableChildrenFn, DraggableId, DraggableLocation, DraggableProps, DraggableProvided, DraggableProvidedDraggableProps, DraggableProvidedDragHandleProps, DraggableRubric, DraggableStateSnapshot, DroppableId, DroppableProps, DroppableProvided, DroppableProvidedProps, DroppableStateSnapshot, DropResult, OnBeforeCaptureResponder, OnBeforeDragStartResponder, OnDragEndResponder, OnDragStartResponder, OnDragUpdateResponder } from '@hello-pangea/dnd';
+export { DragDropContext, Draggable, Droppable } from '@hello-pangea/dnd';

package/dist/types/src/http/client.d.ts

@@ -0,0 +1,112 @@
+import { AxiosProgressEvent } from 'axios';
+import { ApiResult, HttpClientOptions, RequestOptions } from './types';
+/**
+ * The HTTP client.
+ */
+export declare class HttpClient {
+    #private;
+    constructor(options: HttpClientOptions);
+    private initInterceptors;
+    /**
+     * Check if the code matches the target code(s).
+     */
+    private matchesCode;
+    /**
+     * Handle the request interceptor.
+     */
+    private handleRequest;
+    /**
+     * Handle the request error interceptor.
+     */
+    private handleRequestError;
+    /**
+     * Handle the response interceptor.
+     */
+    private handleResponse;
+    /**
+     * Handle the response error interceptor.
+     */
+    private handleResponseError;
+    /**
+     * Handle 401 unauthorized response.
+     */
+    private handleUnauthorized;
+    /**
+     * Log info message using configured handler or console.
+     */
+    private logInfo;
+    /**
+     * Log warning message using configured handler or console.
+     */
+    private logWarning;
+    /**
+     * Log error message using configured handler or console.
+     */
+    private logError;
+    /**
+     * Inject access token into request Authorization header.
+     */
+    private injectAccessToken;
+    /**
+     * Replace path parameters in the URL (e.g., /users/:id -> /users/123).
+     */
+    private replacePathParams;
+    /**
+     * Ensure the token is refreshed. Can be called proactively by external code
+     * (e.g., fetch-based SSE) to refresh token before/after request.
+     *
+     * @param triggerCallback - Whether to trigger onUnauthenticated callback on failure.
+     * @returns True if token refresh succeeded, false otherwise.
+     */
+    ensureTokenRefreshed(triggerCallback?: boolean): Promise<boolean>;
+    /**
+     * Try to refresh the token using the provided refresh callback.
+     */
+    private tryRefreshToken;
+    /**
+     * Retry the request with refreshed token.
+     */
+    private retryRequest;
+    /**
+     * GET request.
+     */
+    get<R = unknown, P = unknown>(url: string, options?: RequestOptions & {
+        params?: P;
+    }): Promise<ApiResult<R>>;
+    /**
+     * POST request.
+     */
+    post<R = unknown, D = unknown, P = unknown>(url: string, options?: RequestOptions & {
+        data?: D;
+        params?: P;
+    }): Promise<ApiResult<R>>;
+    /**
+     * PUT request.
+     */
+    put<R = unknown, D = unknown, P = unknown>(url: string, options?: RequestOptions & {
+        data?: D;
+        params?: P;
+    }): Promise<ApiResult<R>>;
+    /**
+     * DELETE request.
+     */
+    delete<R = unknown, P = unknown>(url: string, options?: RequestOptions & {
+        params?: P;
+    }): Promise<ApiResult<R>>;
+    /**
+     * Upload file via multipart/form-data.
+     */
+    upload<R = unknown, P = unknown>(url: string, options?: RequestOptions & {
+        params?: P;
+        data: FormData;
+        onProgress?: (event: AxiosProgressEvent) => void;
+    }): Promise<ApiResult<R>>;
+    /**
+     * Download file as blob and trigger browser download.
+     */
+    download<P = unknown>(url: string, options?: RequestOptions & {
+        params?: P;
+        onProgress?: (progress: AxiosProgressEvent) => void;
+        filename?: string | ((filename: string) => string);
+    }): Promise<void>;
+}

package/dist/types/src/http/constants.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The key for the HTTP client in dependency injection.
+ */
+export declare const HTTP_CLIENT_KEY = "__vef_http_client_key";
+/**
+ * The regex for path parameters in URLs (e.g., /users/:id).
+ */
+export declare const PATH_PARAM_REGEX: RegExp;
+/**
+ * The regex for extracting filename from Content-Disposition header.
+ */
+export declare const CONTENT_DISPOSITION_FILENAME_REGEX: RegExp;
+/**
+ * The header name for skipping authentication.
+ */
+export declare const SKIP_AUTH_HEADER = "X-Skip-Authentication";
+/**
+ * The header value for skipping authentication.
+ */
+export declare const SKIP_AUTH_VALUE = "1";
+/**
+ * Default request timeout in milliseconds (30 seconds).
+ */
+export declare const DEFAULT_TIMEOUT = 30000;

package/dist/types/src/http/errors.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Business error returned by the API when the response code indicates a business logic failure.
+ */
+export declare class BusinessError extends Error {
+    /**
+     * The business error code from the API response.
+     */
+    readonly code: number;
+    /**
+     * The original API response data.
+     */
+    readonly data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
+}

package/dist/types/src/http/helpers.d.ts

@@ -0,0 +1,17 @@
+import { HttpClientOptions } from './types';
+import { HttpClient } from './client';
+import { BusinessError } from './errors';
+/**
+ * Create the http client.
+ *
+ * @param options - The options for the http client.
+ * @returns The http client.
+ */
+export declare function createHttpClient(options: HttpClientOptions): Readonly<HttpClient>;
+/**
+ * Type guard to check if an error is a BusinessError.
+ *
+ * @param error - The error to check.
+ * @returns True if the error is a BusinessError.
+ */
+export declare function isBusinessError(error: unknown): error is BusinessError;

package/dist/types/src/http/index.d.ts

@@ -0,0 +1,5 @@
+export { HttpClient } from './client';
+export { CONTENT_DISPOSITION_FILENAME_REGEX, DEFAULT_TIMEOUT, HTTP_CLIENT_KEY, PATH_PARAM_REGEX, SKIP_AUTH_HEADER, SKIP_AUTH_VALUE, SKIP_AUTH_HEADER as skipAuthenticationHeader, SKIP_AUTH_VALUE as skipAuthenticationValue } from './constants';
+export { BusinessError } from './errors';
+export { createHttpClient, isBusinessError } from './helpers';
+export type * from './types';

package/dist/types/src/http/types.d.ts

@@ -0,0 +1,101 @@
+import { Awaitable, MaybeArray, MaybeUndefined } from '@vef-framework-react/shared';
+import { AxiosProgressEvent, GenericAbortSignal, RawAxiosRequestHeaders } from 'axios';
+export type ProgressEvent = AxiosProgressEvent;
+/**
+ * The result of the API.
+ */
+export interface ApiResult<T = unknown> {
+    /**
+     * The code of the API.
+     */
+    readonly code: number;
+    /**
+     * The message of the API.
+     */
+    readonly message: string;
+    /**
+     * The data of the API.
+     */
+    readonly data: T;
+}
+/**
+ * The authenticated tokens.
+ */
+export interface AuthTokens {
+    /**
+     * The access token
+     */
+    accessToken: string;
+    /**
+     * The refresh token
+     */
+    refreshToken: string;
+}
+/**
+ * The options for the HTTP client.
+ */
+export interface HttpClientOptions {
+    /**
+     * The base URL of the API.
+     */
+    baseUrl: string;
+    /**
+     * The timeout of the request.
+     */
+    timeout?: number;
+    /**
+     * The function to get the authentication tokens.
+     */
+    getAuthTokens?: () => Awaitable<MaybeUndefined<Readonly<AuthTokens>>>;
+    /**
+     * The function to set the authentication tokens.
+     */
+    setAuthTokens?: (tokens: Readonly<AuthTokens>) => Awaitable<void>;
+    /**
+     * The function to refresh the authentication tokens.
+     * Receives the current tokens and should return new tokens.
+     * If refresh fails, the promise should reject.
+     */
+    refreshToken?: (tokens: Readonly<AuthTokens>) => Awaitable<Readonly<AuthTokens>>;
+    /**
+     * The codes that are considered as successful.
+     */
+    okCode?: MaybeArray<number>;
+    /**
+     * The codes that are considered as authentication token expired.
+     */
+    tokenExpiredCode?: MaybeArray<number>;
+    /**
+     * The function to handle the unauthenticated error.
+     */
+    onUnauthenticated?: () => Awaitable<void>;
+    /**
+     * The function to handle the access denied error.
+     */
+    onAccessDenied?: () => Awaitable<void>;
+    /**
+     * The function to show the info message.
+     */
+    showInfoMessage?: (message: string) => void;
+    /**
+     * The function to show the warning message.
+     */
+    showWarningMessage?: (message: string) => void;
+    /**
+     * The function to show the error message.
+     */
+    showErrorMessage?: (message: string) => void;
+}
+/**
+ * The options for the request.
+ */
+export interface RequestOptions {
+    /**
+     * The signal for the request.
+     */
+    signal?: GenericAbortSignal;
+    /**
+     * The headers for the request.
+     */
+    headers?: RawAxiosRequestHeaders;
+}

package/dist/types/src/immer/index.d.ts

@@ -0,0 +1,2 @@
+export { applyPatches, current as currentState, original as originalState, produce, produceWithPatches } from 'immer';
+export { useImmer, useImmerReducer } from 'use-immer';

package/dist/types/src/index.d.ts

@@ -0,0 +1,16 @@
+export * from './ai';
+export { ApiClient, createApiClient, HTTP_CLIENT, QUERY_CLIENT, type ApiClientOptions, type MutationFunction, type QueryFunction, type QueryKey } from './api';
+export { checkPermission, type PermissionCheckMode } from './auth';
+export { type DataOption, type DataOptionWithPinyin, type PaginationParams, type PaginationResult } from './common';
+export { ApiClientProvider, AppContextProvider, createContextWithSelector, DisabledProvider, useApiClient, useAppContext, useDisabled, type AppContext, type SelectorContextProviderProps, type SelectorContextResult, type UseSelectorContext } from './context';
+export { AxisModifier, DragDropContext, DragDropProvider, Draggable, DragOverlay, Droppable, KeyboardSensor, moveArrayItem, moveDragItem, PointerSensor, restrictShapeToBoundingRectangle, RestrictToElement, RestrictToHorizontalAxis, RestrictToVerticalAxis, RestrictToWindow, SnapModifier, swapArrayItem, swapDragItem, useDragDropMonitor, useDraggable, useDroppable, useSortable, type DragDropContextProps, type DragDropEventHandlers, type DragDropEvents, type DraggableChildrenFn, type DraggableId, type DraggableLocation, type DraggableProps, type DraggableProvided, type DraggableProvidedDraggableProps, type DraggableProvidedDragHandleProps, type DraggableRubric, type DraggableStateSnapshot, type DroppableId, type DroppableProps, type DroppableProvided, type DroppableProvidedProps, type DroppableStateSnapshot, type DropResult, type OnBeforeCaptureResponder, type OnBeforeDragStartResponder, type OnDragEndResponder, type OnDragStartResponder, type OnDragUpdateResponder } from './dnd';
+export type { ApiResult, AuthTokens, BusinessError, HttpClient, HttpClientOptions, isBusinessError, ProgressEvent, RequestOptions } from './http';
+export { skipAuthenticationHeader, skipAuthenticationValue } from './http';
+export { applyPatches, currentState, originalState, produce, produceWithPatches, useImmer, useImmerReducer } from './immer';
+export { AnimatePresence, LayoutGroup, motion, MotionProvider, Reorder, useDragControls, useInView, type MotionProps, type ResolvedValues, type TargetAndTransition, type Transition, type Variant, type VariantLabels, type Variants } from './motion';
+export { keepPreviousData, matchMutation, matchQuery, skipQueryToken, useInfiniteQuery, useIsFetching, useIsMutating, useMutation, useMutationState, useQueries, useQuery, useQueryErrorResetBoundary, type DefinedInitialDataOptions, type DefinedUseQueryResult, type InitialDataFunction, type MutationFunctionContext, type MutationMeta, type MutationScope, type PlaceholderDataFunction, type QueryClientOptions, type QueryKeyHashFunction, type QueryMeta, type RefetchOptions, type RetryDelayFunction, type RetryDelayValue, type RetryValue, type ShouldRetryFunction, type SkipQueryToken, type StaleTime, type UndefinedInitialDataOptions, type UseInfiniteQueryOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult } from './query';
+export { createSseClient, SseClient, type SseClientOptions, type SseEventHandlers, type SseMessageEvent, type SseRequestConfig } from './sse';
+export { atom, AtomStoreProvider, createAtomStore, getDefaultAtomStore, useAtom, useAtomStore, useAtomValue, useSetAtom, type Atom, type AtomGetter, type AtomSetter, type ExtractAtomArgs, type ExtractAtomResult, type ExtractAtomValue, type PrimitiveAtom, type SetStateAction, type WritableAtom } from './state';
+export { Actor, createActor, createMachine, updateContext, useActor, useActorRef, type ActorLogic, type ActorOptions, type AnyActorLogic, type AnyMachineSnapshot, type AnyStateMachine, type MachineConfig, type MachineContext, type MachineSnapshot, type RequiredActorOptionsKeys, type SnapshotFrom, type StateMachine } from './state-machine';
+export { createComponentStore, createPersistedStore, createStore, useDeep, useShallow, type PersistenceOptions, type ReturnedComponentStoreResult, type SliceStateCreator, type StoreProviderProps, type UnboundStore, type UseBoundStore, type UseBoundStoreWithPersist, type UseStore } from './store';
+export { clsx, type ClassArray, type ClassDictionary, type ClassValue } from 'clsx';

package/dist/types/src/motion/features.d.ts

@@ -0,0 +1 @@
+export { domMax as default } from 'motion/react';

package/dist/types/src/motion/index.d.ts

@@ -0,0 +1,4 @@
+export { default as MotionProvider } from './motion-provider.js';
+export type { MotionProps, ResolvedValues, TargetAndTransition, Transition, Variant, VariantLabels, Variants } from 'motion/react';
+export { AnimatePresence, LayoutGroup, Reorder, useDragControls, useInView } from 'motion/react';
+export * as motion from 'motion/react-m';

package/dist/types/src/motion/motion-provider.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+interface MotionProviderProps {
+    children: ReactNode;
+}
+/**
+ * Motion provider component that wraps the application with LazyMotion and MotionConfig.
+ * Uses lazy loading for motion features to optimize bundle size.
+ */
+export default function MotionProvider({ children }: MotionProviderProps): ReactNode;
+export {};

package/dist/types/src/query/constants.d.ts

@@ -0,0 +1 @@
+export declare const QUERY_CLIENT_KEY = "__vef_query_client_key";

package/dist/types/src/query/helpers.d.ts

@@ -0,0 +1,7 @@
+import { QueryClientOptions } from './types';
+import { QueryClient } from '@tanstack/react-query';
+/**
+ * Creates a configured QueryClient instance with mutation cache and default options
+ */
+export declare function createQueryClient(options?: QueryClientOptions): QueryClient;
+export { keepPreviousData } from '@tanstack/react-query';

package/dist/types/src/query/hooks.d.ts

@@ -0,0 +1,27 @@
+import { DefinedInitialDataInfiniteOptions, DefinedInitialDataOptions, DefinedUseInfiniteQueryResult, DefinedUseQueryResult, InfiniteData, MutationFilters, MutationState, NoInfer, QueriesResults, QueryFilters, UndefinedInitialDataInfiniteOptions, UndefinedInitialDataOptions, UseInfiniteQueryResult, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult, useMutationState as useMutationStateInternal, useQueries as useQueriesInternal } from '@tanstack/react-query';
+import { QueryKey } from '../api';
+export declare function useQuery<TQueryFnData = unknown, TData = TQueryFnData, TParams = never>(options: DefinedInitialDataOptions<TQueryFnData, Error, TData, QueryKey<TParams>>): DefinedUseQueryResult<NoInfer<TData>, Error>;
+export declare function useQuery<TQueryFnData = unknown, TData = TQueryFnData, TParams = never>(options: UndefinedInitialDataOptions<TQueryFnData, Error, TData, QueryKey<TParams>> | UseQueryOptions<TQueryFnData, Error, TData, QueryKey<TParams>>): UseQueryResult<NoInfer<TData>, Error>;
+export declare function useInfiniteQuery<TQueryFnData, TData = InfiniteData<TQueryFnData>, TParams = never, TPageParam = never>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, Error, TData, QueryKey<TParams>, TPageParam>): DefinedUseInfiniteQueryResult<TData, Error>;
+export declare function useInfiniteQuery<TQueryFnData, TData = InfiniteData<TQueryFnData>, TParams = never, TPageParam = never>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, Error, TData, QueryKey<TParams>, TPageParam>): UseInfiniteQueryResult<TData, Error>;
+/**
+ * Hook for executing multiple queries in parallel
+ */
+export declare function useQueries<T extends unknown[], TCombinedResult = QueriesResults<T>>(options: Parameters<typeof useQueriesInternal<T, TCombinedResult>>[0]): TCombinedResult;
+/**
+ * Hook for executing mutations with automatic error typing
+ */
+export declare function useMutation<TData = unknown, TParams = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, Error, TParams, TOnMutateResult>): UseMutationResult<TData, Error, TParams, TOnMutateResult>;
+/**
+ * Hook for accessing mutation state across the application
+ */
+export declare function useMutationState<TResult = MutationState>(options?: Parameters<typeof useMutationStateInternal<TResult>>[0]): TResult[];
+/**
+ * Hook for getting the count of currently fetching queries
+ */
+export declare function useIsFetching(filters?: QueryFilters): number;
+/**
+ * Hook for getting the count of currently executing mutations
+ */
+export declare function useIsMutating(filters?: MutationFilters): number;
+export { matchMutation, matchQuery, skipToken as skipQueryToken, useQueryErrorResetBoundary } from '@tanstack/react-query';

package/dist/types/src/query/index.d.ts

@@ -0,0 +1,4 @@
+export { QUERY_CLIENT_KEY } from './constants';
+export { createQueryClient, keepPreviousData } from './helpers';
+export { matchMutation, matchQuery, skipQueryToken, useInfiniteQuery, useIsFetching, useIsMutating, useMutation, useMutationState, useQueries, useQuery, useQueryErrorResetBoundary } from './hooks';
+export type * from './types';

package/dist/types/src/query/types.d.ts

@@ -0,0 +1,51 @@
+import { DefinedInitialDataOptions as DefinedInitialDataOptionsInternal, DefinedUseQueryResult as DefinedUseQueryResultInternal, QueryKeyHashFunction as QueryKeyHashFunctionInternal, UndefinedInitialDataOptions as UndefinedInitialDataOptionsInternal, UseInfiniteQueryOptions as UseInfiniteQueryOptionsInternal, UseMutationResult as UseMutationResultInternal, UseQueryOptions as UseQueryOptionsInternal, UseQueryResult as UseQueryResultInternal } from '@tanstack/react-query';
+import { MaybeUndefined } from '@vef-framework-react/shared';
+import { QueryKey } from '../api';
+declare module "@tanstack/react-query" {
+    interface Register {
+        mutationMeta: {
+            /**
+             * Query keys to invalidate on successful mutation
+             */
+            invalidates?: Array<QueryKey<never> | QueryKey<unknown>>;
+            /**
+             * Whether to show success feedback (default: true)
+             */
+            shouldShowSuccessFeedback?: boolean;
+        };
+    }
+}
+/**
+ * Options for creating a QueryClient instance
+ */
+export interface QueryClientOptions {
+    /**
+     * Time in ms before data is considered stale (default: 5000)
+     */
+    staleTime?: number;
+    /**
+     * Time in ms before inactive queries are garbage collected (default: 300000)
+     */
+    gcTime?: number;
+    /**
+     * Callback to display success message from mutation response
+     */
+    showSuccessMessage?: (message: string) => void;
+}
+export type ShouldRetryFunction = (failureCount: number, error: Error) => boolean;
+export type RetryValue = boolean | number | ShouldRetryFunction;
+export type RetryDelayFunction = (failureCount: number, error: Error) => number;
+export type RetryDelayValue = number | RetryDelayFunction;
+export type PlaceholderDataFunction<TData = unknown> = (previousData: MaybeUndefined<TData>) => MaybeUndefined<TData>;
+export interface RefetchOptions {
+    cancelRefetch?: boolean;
+}
+export type QueryKeyHashFunction<TParams = never> = QueryKeyHashFunctionInternal<QueryKey<TParams>>;
+export type UseQueryResult<TData = unknown> = UseQueryResultInternal<TData, Error>;
+export type DefinedUseQueryResult<TData = unknown> = DefinedUseQueryResultInternal<TData, Error>;
+export type UseQueryOptions<TQueryFnData = unknown, TData = TQueryFnData, TParams = never> = UseQueryOptionsInternal<TQueryFnData, Error, TData, QueryKey<TParams>>;
+export type DefinedInitialDataOptions<TQueryFnData = unknown, TData = TQueryFnData, TParams = never> = DefinedInitialDataOptionsInternal<TQueryFnData, Error, TData, QueryKey<TParams>>;
+export type UndefinedInitialDataOptions<TQueryFnData = unknown, TData = TQueryFnData, TParams = never> = UndefinedInitialDataOptionsInternal<TQueryFnData, Error, TData, QueryKey<TParams>>;
+export type UseInfiniteQueryOptions<TQueryFnData, TData = TQueryFnData, TParams = never, TPageParam = never> = UseInfiniteQueryOptionsInternal<TQueryFnData, Error, TData, QueryKey<TParams>, TPageParam>;
+export type UseMutationResult<TData = unknown, TParams = unknown, TOnMutateResult = unknown> = UseMutationResultInternal<TData, Error, TParams, TOnMutateResult>;
+export type { InitialDataFunction, MutationFunctionContext, MutationMeta, MutationScope, QueryMeta, SkipToken as SkipQueryToken, StaleTime } from '@tanstack/react-query';

package/dist/types/src/sse/client.d.ts

@@ -0,0 +1,16 @@
+import { SseClientOptions, SseEventHandlers, SseRequestConfig } from './types';
+/**
+ * SSE client wrapper around @microsoft/fetch-event-source.
+ */
+export declare class SseClient {
+    #private;
+    constructor(options?: SseClientOptions);
+    /**
+     * Start an SSE stream request.
+     */
+    stream(config: SseRequestConfig, handlers: SseEventHandlers): Promise<void>;
+    /**
+     * Abort all active stream requests.
+     */
+    abort(): void;
+}