@wisemen/vue-core-api-utils 1.2.0 → 2.0.0

package/dist/index.d.mts

@@ -1,42 +1,43 @@
 import { Result } from "neverthrow";
 import { QueryClient as QueryClient$1, QueryClient as TanstackQueryClient, QueryClientConfig } from "@tanstack/vue-query";
-import { App, ComputedRef, MaybeRef, Ref } from "vue";
+import { App, ComputedRef, MaybeRef, MaybeRefOrGetter, Ref } from "vue";
+import z from "zod";
 
 //#region src/async-result/asyncResult.d.ts
 /**
  * Base class for AsyncResult - internal use only.
  * Use AsyncResult<T, E> as the public type.
  */
-declare abstract class AsyncResultBase<T, E> {
-  protected readonly _error: E | undefined;
+declare abstract class AsyncResultBase<T, E$1> {
+  protected readonly _error: E$1 | undefined;
   protected readonly _status: 'err' | 'loading' | 'ok';
   protected readonly _value: T | undefined;
-  protected constructor(status: 'err' | 'loading' | 'ok', value?: T, error?: E);
+  protected constructor(status: 'err' | 'loading' | 'ok', value?: T, error?: E$1);
   /**
    * Check if the result is an error (type predicate for narrowing)
    */
-  isErr(): this is AsyncResultErr<T, E>;
+  isErr(): this is AsyncResultErr<T, E$1>;
   /**
    * Check if the result is in loading state (type predicate for narrowing)
    */
-  isLoading(): this is AsyncResultLoading<T, E>;
+  isLoading(): this is AsyncResultLoading<T, E$1>;
   /**
    * Check if the result is a success (type predicate for narrowing)
    */
-  isOk(): this is AsyncResultOk<T, E>;
+  isOk(): this is AsyncResultOk<T, E$1>;
   /**
    * Map the success value to a new value
    */
-  map<U>(fn: (value: T) => U): AsyncResult<U, E>;
+  map<U>(fn: (value: T) => U): AsyncResult<U, E$1>;
   /**
    * Map the error to a new error
    */
-  mapErr<F>(fn: (error: E) => F): AsyncResult<T, F>;
+  mapErr<F>(fn: (error: E$1) => F): AsyncResult<T, F>;
   /**
    * Pattern match on all three states
    */
   match<U>(handlers: {
-    err: (error: E) => U;
+    err: (error: E$1) => U;
     loading: () => U;
     ok: (value: T) => U;
   }): U;
@@ -54,31 +55,31 @@ declare abstract class AsyncResultBase<T, E> {
 /**
  * AsyncResult representing an error state
  */
-declare class AsyncResultErr<T, E> extends AsyncResultBase<T, E> {
+declare class AsyncResultErr<T, E$1> extends AsyncResultBase<T, E$1> {
   private constructor();
   /** @internal */
-  static _create<T, E>(error: E): AsyncResultErr<T, E>;
+  static _create<T, E$1>(error: E$1): AsyncResultErr<T, E$1>;
   /** Get the error value - only available after isErr() check */
-  getError(): E;
-  getResult(): Result<T, E>;
+  getError(): E$1;
+  getResult(): Result<T, E$1>;
 }
 /**
  * AsyncResult representing a loading state
  */
-declare class AsyncResultLoading<T, E> extends AsyncResultBase<T, E> {
+declare class AsyncResultLoading<T, E$1> extends AsyncResultBase<T, E$1> {
   private constructor();
   /** @internal */
-  static _create<T, E>(): AsyncResultLoading<T, E>;
+  static _create<T, E$1>(): AsyncResultLoading<T, E$1>;
   getResult(): null;
 }
 /**
  * AsyncResult representing a success state
  */
-declare class AsyncResultOk<T, E> extends AsyncResultBase<T, E> {
+declare class AsyncResultOk<T, E$1> extends AsyncResultBase<T, E$1> {
   private constructor();
   /** @internal */
-  static _create<T, E>(value: T): AsyncResultOk<T, E>;
-  getResult(): Result<T, E>;
+  static _create<T, E$1>(value: T): AsyncResultOk<T, E$1>;
+  getResult(): Result<T, E$1>;
   /** Get the success value - only available after isOk() check */
   getValue(): T;
 }
@@ -86,7 +87,7 @@ declare class AsyncResultOk<T, E> extends AsyncResultBase<T, E> {
  * Union type of all AsyncResult states.
  * Use isOk(), isErr(), or isLoading() to narrow to specific state.
  */
-type AsyncResult<T, E> = AsyncResultErr<T, E> | AsyncResultLoading<T, E> | AsyncResultOk<T, E>;
+type AsyncResult<T, E$1> = AsyncResultErr<T, E$1> | AsyncResultLoading<T, E$1> | AsyncResultOk<T, E$1>;
 /**
  * Static factory methods for creating AsyncResult instances.
  * This pattern (same name for type and value) is intentional for ergonomic API.
@@ -95,21 +96,41 @@ declare const AsyncResult: {
   /**
    * Create a failed AsyncResult with error
    */
-  readonly err: <T, E>(error: E) => AsyncResultErr<T, E>;
+  readonly err: <T, E$1>(error: E$1) => AsyncResultErr<T, E$1>;
   /**
    * Create an AsyncResult from an existing neverthrow Result
    */
-  readonly fromResult: <T, E>(result: Result<T, E>) => AsyncResult<T, E>;
+  readonly fromResult: <T, E$1>(result: Result<T, E$1>) => AsyncResult<T, E$1>;
   /**
    * Create a loading AsyncResult
    */
-  readonly loading: <T, E>() => AsyncResultLoading<T, E>;
+  readonly loading: <T, E$1>() => AsyncResultLoading<T, E$1>;
   /**
    * Create a successful AsyncResult with data
    */
-  readonly ok: <T, E>(value: T) => AsyncResultOk<T, E>;
+  readonly ok: <T, E$1>(value: T) => AsyncResultOk<T, E$1>;
 };
 //#endregion
+//#region src/register.d.ts
+interface Register {}
+type RegisteredQueryKeys = Register extends {
+  queryKeys: infer T;
+} ? T extends object ? T : object : object;
+type RegisteredErrorCodes = Register extends {
+  errorCodes: infer T;
+} ? T extends string ? T : string : string;
+type RegisteredApiUseMutationOptions<TReqData, TResData, TParams = void> = UseMutationOptions<TReqData, TResData, TParams, RegisteredErrorCodes>;
+type RegisteredQueryKeyInput = { [K in keyof RegisteredQueryKeys]?: RegisteredQueryKeys[K] extends {
+  params: infer P;
+} ? P : unknown };
+type RegisteredQueryKeyConfig<TKey extends PropertyKey> = RegisteredQueryKeys extends Record<TKey, infer V> ? V : unknown;
+type RegisteredQueryKeyEntity<TKey extends PropertyKey> = RegisteredQueryKeyConfig<TKey> extends {
+  entity: infer E;
+} ? E : unknown;
+type RegisteredQueryKeyParams<TKey extends PropertyKey> = RegisteredQueryKeyConfig<TKey> extends {
+  params: infer P;
+} ? P : undefined;
+//#endregion
 //#region src/types/apiError.type.d.ts
 interface ApiKnownErrorObject<TCode extends string = string> {
   code: TCode;
@@ -137,7 +158,7 @@ type ApiResult<T, TCode extends string = string> = Result<T, ApiError<TCode>>;
 type AsyncApiResult<T, TCode extends string = string> = AsyncResult<T, ApiError<TCode>>;
 //#endregion
 //#region src/composables/mutation/mutation.composable.d.ts
-type RequestParams$1<TReqData, TParams> = TReqData extends void ? TParams extends void ? void : {
+type RequestParams<TReqData, TParams> = TReqData extends void ? TParams extends void ? void : {
   params: TParams;
 } : TParams extends void ? {
   body: TReqData;
@@ -145,7 +166,33 @@ type RequestParams$1<TReqData, TParams> = TReqData extends void ? TParams extend
   body: TReqData;
   params: TParams;
 };
-interface UseMutationReturnType<TReqData, TResData, TParams = void, TErrorCode extends string = string> {
+interface UseMutationOptions<TReqData, TResData, TParams = void, TErrorCode extends string = RegisteredErrorCodes> {
+  /**
+   * Whether to enable debug mode
+   */
+  isDebug?: boolean;
+  /**
+   * Function that will be called to perform the mutation
+   * @param options - Parameters and body for the mutation
+   * @returns Promise with ApiResult containing either the response data or an error
+   */
+  queryFn: (options: RequestParams<TReqData, TParams>) => Promise<ApiResult<TResData, TErrorCode>>;
+  /**
+   * Object where each key is a query key to invalidate after mutation succeeds.
+   * Each query key can optionally have nested parameter extractors.
+   * @example
+   * ```typescript
+   * queryKeysToInvalidate: {
+   *   contactDetail: {
+   *     contactUuid: (params, result) => params.contactUuid,
+   *   },
+   *   contactIndex: {},
+   * }
+   * ```
+   */
+  queryKeysToInvalidate?: { [K in keyof RegisteredQueryKeyInput]?: Record<string, (params: TParams, data: TResData) => any> };
+}
+interface UseMutationReturnType<TReqData, TResData, TParams = void, TErrorCode extends string = RegisteredErrorCodes> {
   /**
    * Whether mutation is loading
    * @deprecated - use `result.value.isLoading()` instead
@@ -161,7 +208,7 @@ interface UseMutationReturnType<TReqData, TResData, TParams = void, TErrorCode e
    * @param data - Parameters and body for the mutation
    * @returns Promise with ApiResult containing either the response data or an error
    */
-  execute: (data: RequestParams$1<TReqData, TParams>) => Promise<ApiResult<TResData, TErrorCode>>;
+  execute: (data: RequestParams<TReqData, TParams>) => Promise<ApiResult<TResData, TErrorCode>>;
   /**
    * Computed result of the mutation
    * Returns an AsyncResult with three states:
@@ -171,15 +218,16 @@ interface UseMutationReturnType<TReqData, TResData, TParams = void, TErrorCode e
    */
   result: ComputedRef<AsyncResult<TResData, ApiError<TErrorCode>>>;
 }
+declare function useMutation<TReqData = void, TResData = void, TParams = void, TErrorCode extends string = RegisteredErrorCodes>(options: UseMutationOptions<TReqData, TResData, TParams, TErrorCode>): UseMutationReturnType<TReqData, TResData, TParams, TErrorCode>;
 //#endregion
 //#region src/types/sort.type.d.ts
 declare enum SortDirection {
   ASC = "asc",
   DESC = "desc",
 }
-interface Sort<TKey$1 extends string = string> {
+interface Sort<TKey extends string = string> {
   direction: SortDirection;
-  key: TKey$1;
+  key: TKey;
 }
 //#endregion
 //#region src/types/queryOptions.d.ts
@@ -245,35 +293,38 @@ interface PaginatedDataDto<TSchema> {
 }
 //#endregion
 //#region src/composables/query/keysetInfiniteQuery.composable.d.ts
-interface KeysetInfiniteQueryOptions<TData, TErrorCode extends string = string> {
+type NestedMaybeRefOrGetter$2<T> = { [K in keyof T]: MaybeRefOrGetter<T[K]> };
+type ArrayItemOf$1<E$1> = E$1 extends (infer I)[] ? I : E$1;
+type EntityItemOf$1<TKey extends PropertyKey> = RegisteredQueryKeyConfig<TKey> extends {
+  entity: infer E;
+} ? ArrayItemOf$1<E> : unknown;
+type WithParams$5<TKey extends PropertyKey> = RegisteredQueryKeyParams<TKey> extends undefined ? {
+  params?: undefined;
+} : {
+  params: NestedMaybeRefOrGetter$2<RegisteredQueryKeyParams<TKey>>;
+};
+type KeysetInfiniteQueryOptions<TKey extends keyof RegisteredQueryKeys, TData, TErrorCode extends string = RegisteredErrorCodes> = {
   /**
    * The time in milliseconds after which the query will be considered stale
-   * After this time, the query will be refetched automatically in the background when it is rendered or accessed
    * @default 0
    */
   staleTime?: number;
   /**
    * Whether the query is enabled
-   * If false, the query will not be executed
    * @default true
    */
   isEnabled?: MaybeRef<boolean>;
   /**
-   * Maximum number of items to fetch per page, default can be set in config
+   * Maximum number of items to fetch per page
    * @default 20
    */
   limit?: number;
   /**
    * Function that will be called when query is executed
-   * @returns Promise with response data
    */
   queryFn: (paginationParams: KeysetPaginationParams) => Promise<KeysetPaginationResult<TData, TErrorCode>>;
-  /**
-   * Query key associated with the query
-   */
-  queryKey: Record<string, unknown>;
-}
-interface UseKeysetInfiniteQueryReturnType<TData, TErrorCode extends string = string> {
+} & WithParams$5<TKey>;
+interface UseKeysetInfiniteQueryReturnType<TData, TErrorCode extends string = RegisteredErrorCodes> {
   /**
    * Whether there is a next page available to fetch
    */
@@ -320,37 +371,41 @@ interface UseKeysetInfiniteQueryReturnType<TData, TErrorCode extends string = st
    */
   result: ComputedRef<AsyncResult<KeysetPaginationResponse<TData>, ApiError<TErrorCode>>>;
 }
+declare function useKeysetInfiniteQuery<TKey extends keyof RegisteredQueryKeys, TData = EntityItemOf$1<TKey>, TErrorCode extends string = RegisteredErrorCodes>(key: TKey, options: KeysetInfiniteQueryOptions<TKey, TData, TErrorCode>): UseKeysetInfiniteQueryReturnType<TData, TErrorCode>;
 //#endregion
 //#region src/composables/query/offsetInfiniteQuery.composable.d.ts
-interface OffsetInfiniteQueryOptions<TData, TErrorCode extends string = string> {
+type NestedMaybeRefOrGetter$1<T> = { [K in keyof T]: MaybeRefOrGetter<T[K]> };
+type ArrayItemOf<E$1> = E$1 extends (infer I)[] ? I : E$1;
+type EntityItemOf<TKey extends PropertyKey> = RegisteredQueryKeyConfig<TKey> extends {
+  entity: infer E;
+} ? ArrayItemOf<E> : unknown;
+type WithParams$4<TKey extends PropertyKey> = RegisteredQueryKeyParams<TKey> extends undefined ? {
+  params?: undefined;
+} : {
+  params: NestedMaybeRefOrGetter$1<RegisteredQueryKeyParams<TKey>>;
+};
+type OffsetInfiniteQueryOptions<TKey extends keyof RegisteredQueryKeys, TData, TErrorCode extends string = RegisteredErrorCodes> = {
   /**
    * The time in milliseconds after which the query will be considered stale
-   * After this time, the query will be refetched automatically in the background when it is rendered or accessed
    * @default 0
    */
   staleTime?: number;
   /**
    * Whether the query is enabled
-   * If false, the query will not be executed
    * @default true
    */
   isEnabled?: MaybeRef<boolean>;
   /**
-   * Maximum number of items to fetch per page, default can be set in config
+   * Maximum number of items to fetch per page
    * @default 20
    */
   limit?: number;
   /**
    * Function that will be called when query is executed
-   * @returns Promise with response data
    */
   queryFn: (paginationParams: OffsetPaginationParams) => Promise<OffsetPaginationResult<TData, TErrorCode>>;
-  /**
-   * Query key associated with the query
-   */
-  queryKey: Record<string, unknown>;
-}
-interface UseOffsetInfiniteQueryReturnType<TData, TErrorCode extends string = string> {
+} & WithParams$4<TKey>;
+interface UseOffsetInfiniteQueryReturnType<TData, TErrorCode extends string = RegisteredErrorCodes> {
   /**
    * Whether there is a next page available to fetch
    */
@@ -397,38 +452,110 @@ interface UseOffsetInfiniteQueryReturnType<TData, TErrorCode extends string = st
    */
   result: ComputedRef<AsyncResult<OffsetPaginationResponse<TData>, ApiError<TErrorCode>>>;
 }
+declare function useOffsetInfiniteQuery<TKey extends keyof RegisteredQueryKeys, TData = EntityItemOf<TKey>, TErrorCode extends string = RegisteredErrorCodes>(key: TKey, options: OffsetInfiniteQueryOptions<TKey, TData, TErrorCode>): UseOffsetInfiniteQueryReturnType<TData, TErrorCode>;
+//#endregion
+//#region src/composables/query/prefetchKeysetInfiniteQuery.composable.d.ts
+type WithParams$3<TKey extends PropertyKey> = RegisteredQueryKeyParams<TKey> extends undefined ? {
+  params?: undefined;
+} : {
+  params: RegisteredQueryKeyParams<TKey>;
+};
+type PrefetchKeysetInfiniteQueryOptions<TKey extends keyof RegisteredQueryKeys, TData, TErrorCode extends string = RegisteredErrorCodes> = {
+  /**
+   * The time in milliseconds after which the prefetched query will be considered stale
+   * @default config.prefetchStaleTime
+   */
+  staleTime?: number;
+  /**
+   * Maximum number of items to fetch per page
+   * @default 20
+   */
+  limit?: number;
+  /**
+   * Function that will be called when query is executed
+   */
+  queryFn: (paginationParams: KeysetPaginationParams) => Promise<KeysetPaginationResult<TData, TErrorCode>>;
+} & WithParams$3<TKey>;
+declare function usePrefetchKeysetInfiniteQuery<TKey extends keyof RegisteredQueryKeys, TData = unknown, TErrorCode extends string = RegisteredErrorCodes>(key: TKey, options: PrefetchKeysetInfiniteQueryOptions<TKey, TData, TErrorCode>): {
+  execute: () => Promise<void>;
+};
+//#endregion
+//#region src/composables/query/prefetchOffsetInfiniteQuery.composable.d.ts
+type WithParams$2<TKey extends PropertyKey> = RegisteredQueryKeyParams<TKey> extends undefined ? {
+  params?: undefined;
+} : {
+  params: RegisteredQueryKeyParams<TKey>;
+};
+type PrefetchOffsetInfiniteQueryOptions<TKey extends keyof RegisteredQueryKeys, TData, TErrorCode extends string = RegisteredErrorCodes> = {
+  /**
+   * The time in milliseconds after which the prefetched query will be considered stale
+   * @default config.prefetchStaleTime
+   */
+  staleTime?: number;
+  /**
+   * Maximum number of items to fetch per page
+   * @default 20
+   */
+  limit?: number;
+  /**
+   * Function that will be called when query is executed
+   */
+  queryFn: (paginationParams: OffsetPaginationParams) => Promise<OffsetPaginationResult<TData, TErrorCode>>;
+} & WithParams$2<TKey>;
+declare function usePrefetchOffsetInfiniteQuery<TKey extends keyof RegisteredQueryKeys, TData = unknown, TErrorCode extends string = RegisteredErrorCodes>(key: TKey, options: PrefetchOffsetInfiniteQueryOptions<TKey, TData, TErrorCode>): {
+  execute: () => Promise<void>;
+};
+//#endregion
+//#region src/composables/query/prefetchQuery.composable.d.ts
+type WithParams$1<TKey extends PropertyKey> = RegisteredQueryKeyParams<TKey> extends undefined ? {
+  params?: undefined;
+} : {
+  params: RegisteredQueryKeyParams<TKey>;
+};
+type UsePrefetchQueryOptions<TKey extends keyof RegisteredQueryKeys, TData, TErrorCode extends string = RegisteredErrorCodes> = {
+  /**
+   * The time in milliseconds after which the prefetched query will be considered stale
+   * @default config.prefetchStaleTime
+   */
+  staleTime?: number;
+  /**
+   * Function that will be called when query is executed
+   */
+  queryFn: () => Promise<ApiResult<TData, TErrorCode>>;
+} & WithParams$1<TKey>;
+declare function usePrefetchQuery<TKey extends keyof RegisteredQueryKeys, TData = unknown, TErrorCode extends string = RegisteredErrorCodes>(key: TKey, options: UsePrefetchQueryOptions<TKey, TData, TErrorCode>): {
+  execute: () => Promise<void>;
+};
 //#endregion
 //#region src/composables/query/query.composable.d.ts
-interface UseQueryOptions<TResData, TErrorCode extends string = string> {
+type NestedMaybeRefOrGetter<T> = { [K in keyof T]: MaybeRefOrGetter<T[K]> };
+type WithParams<TKey extends PropertyKey> = RegisteredQueryKeyParams<TKey> extends undefined ? {
+  params?: undefined;
+} : {
+  params: NestedMaybeRefOrGetter<RegisteredQueryKeyParams<TKey>>;
+};
+type UseQueryOptions<TKey extends keyof RegisteredQueryKeys, TData, TErrorCode extends string = RegisteredErrorCodes> = {
   /**
    * The time in milliseconds after which the query will be considered stale
-   * After this time, the query will be refetched automatically in the background when it is rendered or accessed
    * @default 0
    */
   staleTime?: number;
   /**
    * Whether to enable debug mode
-   * When enabled, the query key and parameters will be logged to the console
    * @default false
    */
   isDebug?: boolean;
   /**
    * Whether the query is enabled
-   * If false, the query will not be executed
    * @default true
    */
   isEnabled?: MaybeRef<boolean>;
   /**
    * Function that will be called when query is executed
-   * @returns Promise with response data
    */
-  queryFn: () => Promise<ApiResult<TResData, TErrorCode>>;
-  /**
-   * Query key associated with the query
-   */
-  queryKey: Record<string, unknown>;
-}
-interface UseQueryReturnType<TResData, TErrorCode extends string = string> {
+  queryFn: () => Promise<ApiResult<TData, TErrorCode>>;
+} & WithParams<TKey>;
+interface UseQueryReturnType<TResData, TErrorCode extends string = RegisteredErrorCodes> {
   /**
    * Whether query has errored at least once
    * @deprecated - use `result.value.isErr()` instead
@@ -463,6 +590,7 @@ interface UseQueryReturnType<TResData, TErrorCode extends string = string> {
    */
   result: ComputedRef<AsyncResult<TResData, ApiError<TErrorCode>>>;
 }
+declare function useQuery<TKey extends keyof RegisteredQueryKeys, TData = RegisteredQueryKeyEntity<TKey>, TErrorCode extends string = RegisteredErrorCodes>(key: TKey, options: UseQueryOptions<TKey, TData, TErrorCode>): UseQueryReturnType<TData, TErrorCode>;
 //#endregion
 //#region src/config/config.d.ts
 /**
@@ -493,6 +621,55 @@ interface QueryConfig {
 }
 declare function setQueryConfig(config: Partial<QueryConfig>): void;
 //#endregion
+//#region src/plugin/apiUtilsPlugin.d.ts
+/**
+ * Create a Vue plugin that sets up TanStack Query and initializes API utilities.
+ *
+ * This plugin handles:
+ * - Creating a QueryClient with the provided config
+ * - Installing VueQueryPlugin on the app
+ * - Initializing the global QueryClient for api-utils
+ *
+ * @example
+ * ```typescript
+ * import { apiUtilsPlugin } from '@wisemen/vue-core-api-utils'
+ * import { vueQueryClientConfig } from '@wisemen/vue-core-configs'
+ *
+ * app.use(apiUtilsPlugin(vueQueryClientConfig()))
+ * ```
+ *
+ * @param config - QueryClient configuration
+ * @returns A Vue plugin that can be used with app.use()
+ */
+declare function apiUtilsPlugin(config: QueryClientConfig): {
+  install: (app: App<any>) => void;
+};
+//#endregion
+//#region src/utils/api/api.util.d.ts
+declare class ApiUtil {
+  static fromPromise<T>(promise: PromiseLike<T>, message?: string): Promise<ApiResult<T, RegisteredErrorCodes>>;
+  static getKeysetPaginationNextOffset(keysetPaginationMeta: KeysetPaginationResponse<any>['meta']): number | null;
+  static getResultError(result: AsyncResult<unknown, ApiError> | Result<unknown, ApiError> | null): ApiError<RegisteredErrorCodes> | null;
+  private static isAsyncResult;
+  static void<T, TApiResult extends ApiResult<void>>(result: ApiResult<T>): TApiResult;
+}
+//#endregion
+//#region src/utils/api-error/apiError.util.d.ts
+declare class ApiErrorUtil {
+  static getApiErrorCode(error: ApiExpectedError): string | null;
+  static getApiErrorMessage(error: ApiExpectedError): string | null;
+  static getMessage(error: ApiExpectedError): string | null;
+  static handleApiError({
+    error,
+    message
+  }: {
+    error: unknown;
+    message?: string;
+  }): ApiError<RegisteredErrorCodes>;
+  static isExpectedApiError(error: unknown): error is ApiExpectedError<RegisteredErrorCodes>;
+  static isZodError(error: unknown): error is z.ZodError;
+}
+//#endregion
 //#region src/types/queryKeys.type.d.ts
 /**
  * Generic helper types for libraries/factories that want to infer query key typing
@@ -501,21 +678,14 @@ declare function setQueryConfig(config: Partial<QueryConfig>): void;
 /**
  * Extract the entity type from a query-keys config for a specific key.
  */
-type QueryKeyEntityFromConfig<TQueryKeys extends object, TKey$1 extends PropertyKey> = TKey$1 extends keyof TQueryKeys ? TQueryKeys[TKey$1] extends {
+type QueryKeyEntityFromConfig<TQueryKeys extends object, TKey extends PropertyKey> = TKey extends keyof TQueryKeys ? TQueryKeys[TKey] extends {
   entity: infer E;
 } ? E : never : never;
-/**
- * Extract the params type from a query-keys config for a specific key.
- * Automatically wraps each param in Ref for reactivity.
- */
-type QueryKeyParamsFromConfig<TQueryKeys extends object, TKey$1 extends PropertyKey> = TKey$1 extends keyof TQueryKeys ? TQueryKeys[TKey$1] extends {
-  params: infer P;
-} ? { [K in keyof P]: Ref<P[K]> } : void : never;
 /**
  * Extract the raw params type from a query-keys config for a specific key (unwrapped from Computed).
  * Used for optimistic updates which accept plain values.
  */
-type QueryKeyRawParamsFromConfig<TQueryKeys extends object, TKey$1 extends PropertyKey> = TKey$1 extends keyof TQueryKeys ? TQueryKeys[TKey$1] extends {
+type QueryKeyRawParamsFromConfig<TQueryKeys extends object, TKey extends PropertyKey> = TKey extends keyof TQueryKeys ? TQueryKeys[TKey] extends {
   params: infer P;
 } ? P : void : never;
 /**
@@ -525,137 +695,6 @@ type QueryKeysWithEntityFromConfig<TQueryKeys extends object> = ({ [K in keyof T
   entity: any;
 } ? K : never }[keyof TQueryKeys]) & string;
 //#endregion
-//#region src/factory/createApiUtils.types.d.ts
-/**
- * Helper type to build the invalidation config for a specific query key
- * Maps the query key's params to optional parameter extractors
- */
-type QueryKeyInvalidationConfig<TQueryKeys extends object, TKey$1 extends keyof TQueryKeys, TParams, TResData> = QueryKeyRawParamsFromConfig<TQueryKeys, TKey$1 & string> extends void ? {} : QueryKeyRawParamsFromConfig<TQueryKeys, TKey$1 & string> extends object ? { [ParamKey in keyof QueryKeyRawParamsFromConfig<TQueryKeys, TKey$1 & string>]?: (params: TParams, data: TResData) => QueryKeyRawParamsFromConfig<TQueryKeys, TKey$1 & string>[ParamKey] } : {};
-type QueryKeysWithArrayEntityFromConfig<TQueryKeys extends object> = ({ [K in keyof TQueryKeys]: TQueryKeys[K] extends {
-  entity: any[];
-} ? K : never }[keyof TQueryKeys]) & string;
-type QueryKeyArrayItemFromConfig<TQueryKeys extends object, TKey$1 extends PropertyKey> = QueryKeyEntityFromConfig<TQueryKeys, TKey$1> extends (infer TItem)[] ? TItem : never;
-type ApiUseQueryOptions<TQueryKeys extends object, TKey$1 extends QueryKeysWithEntityFromConfig<TQueryKeys>, TErrorCode extends string = string> = {
-  staleTime?: number;
-  isDebug?: boolean;
-  isEnabled?: MaybeRef<boolean>;
-  queryFn: () => Promise<ApiResult<QueryKeyEntityFromConfig<TQueryKeys, TKey$1>, TErrorCode>>;
-} & (QueryKeyParamsFromConfig<TQueryKeys, TKey$1> extends void ? {
-  params?: QueryKeyParamsFromConfig<TQueryKeys, TKey$1>;
-} : {
-  params: QueryKeyParamsFromConfig<TQueryKeys, TKey$1>;
-});
-type ApiUsePrefetchQueryOptions<TQueryKeys extends object, TKey$1 extends QueryKeysWithEntityFromConfig<TQueryKeys>, TErrorCode extends string = string> = {
-  staleTime?: number;
-  queryFn: () => Promise<ApiResult<QueryKeyEntityFromConfig<TQueryKeys, TKey$1>, TErrorCode>>;
-} & (QueryKeyParamsFromConfig<TQueryKeys, TKey$1> extends void ? {
-  params?: QueryKeyParamsFromConfig<TQueryKeys, TKey$1>;
-} : {
-  params: QueryKeyParamsFromConfig<TQueryKeys, TKey$1>;
-});
-type ApiUseOffsetInfiniteQueryOptions<TQueryKeys extends object, TKey$1 extends QueryKeysWithArrayEntityFromConfig<TQueryKeys>, TErrorCode extends string = string> = {
-  staleTime?: number;
-  isEnabled?: MaybeRef<boolean>;
-  limit?: number;
-  queryFn: (paginationParams: OffsetPaginationParams) => Promise<OffsetPaginationResult<QueryKeyArrayItemFromConfig<TQueryKeys, TKey$1>, TErrorCode>>;
-} & (QueryKeyParamsFromConfig<TQueryKeys, TKey$1> extends void ? {
-  params?: QueryKeyParamsFromConfig<TQueryKeys, TKey$1>;
-} : {
-  params: QueryKeyParamsFromConfig<TQueryKeys, TKey$1>;
-});
-type ApiUseOffsetInfinitePrefetchQueryOptions<TQueryKeys extends object, TKey$1 extends QueryKeysWithArrayEntityFromConfig<TQueryKeys>, TErrorCode extends string = string> = {
-  staleTime?: number;
-  limit?: number;
-  queryFn: (paginationParams: OffsetPaginationParams) => Promise<OffsetPaginationResult<QueryKeyArrayItemFromConfig<TQueryKeys, TKey$1>, TErrorCode>>;
-} & (QueryKeyParamsFromConfig<TQueryKeys, TKey$1> extends void ? {
-  params?: QueryKeyParamsFromConfig<TQueryKeys, TKey$1>;
-} : {
-  params: QueryKeyParamsFromConfig<TQueryKeys, TKey$1>;
-});
-type ApiUseKeysetInfiniteQueryOptions<TQueryKeys extends object, TKey$1 extends QueryKeysWithArrayEntityFromConfig<TQueryKeys>, TErrorCode extends string = string> = {
-  staleTime?: number;
-  isEnabled?: MaybeRef<boolean>;
-  limit?: number;
-  queryFn: (paginationParams: KeysetPaginationParams) => Promise<KeysetPaginationResult<QueryKeyArrayItemFromConfig<TQueryKeys, TKey$1>, TErrorCode>>;
-} & (QueryKeyParamsFromConfig<TQueryKeys, TKey$1> extends void ? {
-  params?: QueryKeyParamsFromConfig<TQueryKeys, TKey$1>;
-} : {
-  params: QueryKeyParamsFromConfig<TQueryKeys, TKey$1>;
-});
-type ApiUseKeysetInfinitePrefetchQueryOptions<TQueryKeys extends object, TKey$1 extends QueryKeysWithArrayEntityFromConfig<TQueryKeys>, TErrorCode extends string = string> = {
-  staleTime?: number;
-  limit?: number;
-  queryFn: (paginationParams: KeysetPaginationParams) => Promise<KeysetPaginationResult<QueryKeyArrayItemFromConfig<TQueryKeys, TKey$1>, TErrorCode>>;
-} & (QueryKeyParamsFromConfig<TQueryKeys, TKey$1> extends void ? {
-  params?: QueryKeyParamsFromConfig<TQueryKeys, TKey$1>;
-} : {
-  params: QueryKeyParamsFromConfig<TQueryKeys, TKey$1>;
-});
-type RequestParams<TReqData, TParams> = TReqData extends void ? TParams extends void ? void : {
-  params: TParams;
-} : TParams extends void ? {
-  body: TReqData;
-} : {
-  body: TReqData;
-  params: TParams;
-};
-interface ApiUseMutationOptions<TQueryKeys extends object, TReqData, TResData, TParams = void, TErrorCode extends string = string> {
-  /**
-   * Whether to enable debug mode
-   */
-  isDebug?: boolean;
-  /**
-   * Function that will be called to perform the mutation
-   * @param options - Parameters and body for the mutation
-   * @returns Promise with ApiResult containing either the response data or an error
-   */
-  queryFn: (options: RequestParams<TReqData, TParams>) => Promise<ApiResult<TResData, TErrorCode>>;
-  /**
-   * Query keys which should be invalidated after mutation is successful
-   * Each key is optional and maps to the query key's specific parameters
-   * @example
-   * ```typescript
-   * queryKeysToInvalidate: {
-   *   userDetail: {
-   *     userUuid: (params, result) => params.userUuid,
-   *   },
-   *   userList: {},
-   * }
-   * ```
-   */
-  queryKeysToInvalidate?: { [TKey in keyof TQueryKeys]?: QueryKeyInvalidationConfig<TQueryKeys, TKey, TParams, TResData> };
-}
-//#endregion
-//#region src/factory/createApiInfiniteQueryUtils.d.ts
-interface CreateApiInfiniteQueryUtilsReturnType<TQueryKeys extends object, TErrorCode extends string = string> {
-  useKeysetInfiniteQuery: <TKey$1 extends QueryKeysWithArrayEntityFromConfig<TQueryKeys>>(key: TKey$1, queryOptions: ApiUseKeysetInfiniteQueryOptions<TQueryKeys, TKey$1, TErrorCode>) => UseKeysetInfiniteQueryReturnType<QueryKeyArrayItemFromConfig<TQueryKeys, TKey$1>, TErrorCode>;
-  useOffsetInfiniteQuery: <TKey$1 extends QueryKeysWithArrayEntityFromConfig<TQueryKeys>>(key: TKey$1, queryOptions: ApiUseOffsetInfiniteQueryOptions<TQueryKeys, TKey$1, TErrorCode>) => UseOffsetInfiniteQueryReturnType<QueryKeyArrayItemFromConfig<TQueryKeys, TKey$1>, TErrorCode>;
-}
-type ApiUseKeysetInfiniteQueryReturnType<TQueryKeys extends object, TKey$1 extends QueryKeysWithArrayEntityFromConfig<TQueryKeys>, TErrorCode extends string = string> = UseKeysetInfiniteQueryReturnType<QueryKeyArrayItemFromConfig<TQueryKeys, TKey$1>, TErrorCode>;
-type ApiUseOffsetInfiniteQueryReturnType<TQueryKeys extends object, TKey$1 extends QueryKeysWithArrayEntityFromConfig<TQueryKeys>, TErrorCode extends string = string> = UseOffsetInfiniteQueryReturnType<QueryKeyArrayItemFromConfig<TQueryKeys, TKey$1>, TErrorCode>;
-//#endregion
-//#region src/factory/createApiMutationUtils.d.ts
-interface CreateApiMutationUtilsReturnType<TQueryKeys extends object, TErrorCode extends string = string> {
-  useMutation: <TReqData = void, TResData = void, TParams = void>(options: ApiUseMutationOptions<TQueryKeys, TReqData, TResData, TParams, TErrorCode>) => UseMutationReturnType<TReqData, TResData, TParams, TErrorCode>;
-}
-//#endregion
-//#region src/factory/createApiPrefetchInfiniteQueryUtils.d.ts
-interface CreateApiPrefetchInfiniteQueryUtilsReturnType<TQueryKeys extends object, TErrorCode extends string = string> {
-  usePrefetchKeysetInfiniteQuery: <TKey$1 extends QueryKeysWithArrayEntityFromConfig<TQueryKeys>>(key: TKey$1, queryOptions: ApiUseKeysetInfinitePrefetchQueryOptions<TQueryKeys, TKey$1, TErrorCode>) => {
-    execute: () => Promise<void>;
-  };
-  usePrefetchOffsetInfiniteQuery: <TKey$1 extends QueryKeysWithArrayEntityFromConfig<TQueryKeys>>(key: TKey$1, queryOptions: ApiUseOffsetInfinitePrefetchQueryOptions<TQueryKeys, TKey$1, TErrorCode>) => {
-    execute: () => Promise<void>;
-  };
-}
-//#endregion
-//#region src/factory/createApiPrefetchQueryUtils.d.ts
-interface CreateApiPrefetchQueryUtilsReturnType<TQueryKeys extends object, TErrorCode extends string = string> {
-  usePrefetchQuery: <TKey$1 extends QueryKeysWithEntityFromConfig<TQueryKeys>>(key: TKey$1, queryOptions: ApiUsePrefetchQueryOptions<TQueryKeys, TKey$1, TErrorCode>) => {
-    execute: () => Promise<void>;
-  };
-}
-//#endregion
 //#region src/utils/query-client/queryClient.d.ts
 /**
  * Helper type to extract the item type from an entity (array item or entity itself)
@@ -729,13 +768,13 @@ declare class QueryClient<TQueryKeys extends object> {
    * const user = queryClient.get(['userDetail', { userUuid: '123' }] as const)
    * ```
    */
-  get<TKey$1 extends QueryKeysWithEntityFromConfig<TQueryKeys>>(queryKey: TKey$1, options?: {
+  get<TKey extends QueryKeysWithEntityFromConfig<TQueryKeys>>(queryKey: TKey, options?: {
     isExact?: false;
-  }): QueryKeyEntityFromConfig<TQueryKeys, TKey$1>[];
-  get<TKey$1 extends QueryKeysWithEntityFromConfig<TQueryKeys>>(queryKey: TKey$1, options: {
+  }): QueryKeyEntityFromConfig<TQueryKeys, TKey>[];
+  get<TKey extends QueryKeysWithEntityFromConfig<TQueryKeys>>(queryKey: TKey, options: {
     isExact: true;
-  }): QueryKeyEntityFromConfig<TQueryKeys, TKey$1> | null;
-  get<TKey$1 extends QueryKeysWithEntityFromConfig<TQueryKeys>>(queryKey: readonly [TKey$1, Partial<QueryKeyRawParamsFromConfig<TQueryKeys, TKey$1>>]): QueryKeyEntityFromConfig<TQueryKeys, TKey$1> | null;
+  }): QueryKeyEntityFromConfig<TQueryKeys, TKey> | null;
+  get<TKey extends QueryKeysWithEntityFromConfig<TQueryKeys>>(queryKey: readonly [TKey, Partial<QueryKeyRawParamsFromConfig<TQueryKeys, TKey>>]): QueryKeyEntityFromConfig<TQueryKeys, TKey> | null;
   /**
    * Invalidate queries to trigger a refetch
    *
@@ -751,8 +790,8 @@ declare class QueryClient<TQueryKeys extends object> {
    * await queryClient.invalidate(['userDetail', { userUuid: '123' }] as const)
    * ```
    */
-  invalidate<TKey$1 extends QueryKeysWithEntityFromConfig<TQueryKeys>>(key: TKey$1): Promise<void>;
-  invalidate<TKey$1 extends QueryKeysWithEntityFromConfig<TQueryKeys>>(keyTuple: readonly [TKey$1, Partial<QueryKeyRawParamsFromConfig<TQueryKeys, TKey$1>>]): Promise<void>;
+  invalidate<TKey extends QueryKeysWithEntityFromConfig<TQueryKeys>>(key: TKey): Promise<void>;
+  invalidate<TKey extends QueryKeysWithEntityFromConfig<TQueryKeys>>(keyTuple: readonly [TKey, Partial<QueryKeyRawParamsFromConfig<TQueryKeys, TKey>>]): Promise<void>;
   /**
    * Set raw entity data in the query cache for a specific query
    * Automatically wraps the entity in AsyncResult
@@ -770,8 +809,8 @@ declare class QueryClient<TQueryKeys extends object> {
    * queryClient.set(['userDetail', { userUuid: '123' }] as const, userData)
    * ```
    */
-  set<TKey$1 extends QueryKeysWithEntityFromConfig<TQueryKeys>>(queryKey: TKey$1, entity: QueryKeyEntityFromConfig<TQueryKeys, TKey$1>): void;
-  set<TKey$1 extends QueryKeysWithEntityFromConfig<TQueryKeys>>(queryKey: readonly [TKey$1, Partial<QueryKeyRawParamsFromConfig<TQueryKeys, TKey$1>>], entity: QueryKeyEntityFromConfig<TQueryKeys, TKey$1>): void;
+  set<TKey extends QueryKeysWithEntityFromConfig<TQueryKeys>>(queryKey: TKey, entity: QueryKeyEntityFromConfig<TQueryKeys, TKey>): void;
+  set<TKey extends QueryKeysWithEntityFromConfig<TQueryKeys>>(queryKey: readonly [TKey, Partial<QueryKeyRawParamsFromConfig<TQueryKeys, TKey>>], entity: QueryKeyEntityFromConfig<TQueryKeys, TKey>): void;
   /**
    * Update entity data in the query cache
    *
@@ -796,76 +835,10 @@ declare class QueryClient<TQueryKeys extends object> {
    * })
    * ```
    */
-  update<TKey$1 extends QueryKeysWithEntityFromConfig<TQueryKeys>, TEntity extends QueryKeyEntityFromConfig<TQueryKeys, TKey$1> = QueryKeyEntityFromConfig<TQueryKeys, TKey$1>>(key: TKey$1, options: QueryClientUpdateOptions<TEntity>): QueryClientUpdateResult;
-  update<TKey$1 extends QueryKeysWithEntityFromConfig<TQueryKeys>, TEntity extends QueryKeyEntityFromConfig<TQueryKeys, TKey$1> = QueryKeyEntityFromConfig<TQueryKeys, TKey$1>>(keyTuple: readonly [TKey$1, Partial<QueryKeyRawParamsFromConfig<TQueryKeys, TKey$1>>], options: QueryClientUpdateOptions<TEntity>): QueryClientUpdateResult;
-}
-//#endregion
-//#region src/factory/createApiQueryClientUtils.d.ts
-interface CreateApiQueryClientUtilsReturnType<TQueryKeys extends object> {
-  useQueryClient: () => QueryClient<TQueryKeys>;
+  update<TKey extends QueryKeysWithEntityFromConfig<TQueryKeys>, TEntity extends QueryKeyEntityFromConfig<TQueryKeys, TKey> = QueryKeyEntityFromConfig<TQueryKeys, TKey>>(key: TKey, options: QueryClientUpdateOptions<TEntity>): QueryClientUpdateResult;
+  update<TKey extends QueryKeysWithEntityFromConfig<TQueryKeys>, TEntity extends QueryKeyEntityFromConfig<TQueryKeys, TKey> = QueryKeyEntityFromConfig<TQueryKeys, TKey>>(keyTuple: readonly [TKey, Partial<QueryKeyRawParamsFromConfig<TQueryKeys, TKey>>], options: QueryClientUpdateOptions<TEntity>): QueryClientUpdateResult;
 }
 //#endregion
-//#region src/factory/createApiQueryUtils.d.ts
-interface CreateApiQueryUtilsReturnType<TQueryKeys extends object, TErrorCode extends string = string> {
-  useQuery: <TKey$1 extends QueryKeysWithEntityFromConfig<TQueryKeys>>(key: TKey$1, queryOptions: ApiUseQueryOptions<TQueryKeys, TKey$1, TErrorCode>) => UseQueryReturnType<QueryKeyEntityFromConfig<TQueryKeys, TKey$1>>;
-}
-//#endregion
-//#region src/factory/createApiUtils.d.ts
-/**
- * Factory that creates typed composables based on a user-provided query-keys config.
- *
- * Requires `initializeApiUtils(queryClient)` to be called first.
- *
- * @example
- * ```typescript
- * // In app setup (plugin or main.ts):
- * initializeApiUtils(queryClient)
- *
- * // In your api lib:
- * export const { useQuery, useMutation, useQueryClient } = createApiUtils<MyQueryKeys>()
- * ```
- */
-declare function createApiUtils<TQueryKeys extends object, TErrorCode extends string = string>(): {
-  useQueryClient: () => QueryClient<TQueryKeys>;
-  useMutation: <TReqData = void, TResData = void, TParams = void>(options: ApiUseMutationOptions<TQueryKeys, TReqData, TResData, TParams, TErrorCode>) => UseMutationReturnType<TReqData, TResData, TParams, TErrorCode>;
-  useKeysetInfiniteQuery: <TKey$1 extends QueryKeysWithArrayEntityFromConfig<TQueryKeys>>(key: TKey$1, queryOptions: ApiUseKeysetInfiniteQueryOptions<TQueryKeys, TKey$1, TErrorCode>) => UseKeysetInfiniteQueryReturnType<QueryKeyArrayItemFromConfig<TQueryKeys, TKey$1>, TErrorCode>;
-  useOffsetInfiniteQuery: <TKey$1 extends QueryKeysWithArrayEntityFromConfig<TQueryKeys>>(key: TKey$1, queryOptions: ApiUseOffsetInfiniteQueryOptions<TQueryKeys, TKey$1, TErrorCode>) => UseOffsetInfiniteQueryReturnType<QueryKeyArrayItemFromConfig<TQueryKeys, TKey$1>, TErrorCode>;
-  usePrefetchKeysetInfiniteQuery: <TKey$1 extends QueryKeysWithArrayEntityFromConfig<TQueryKeys>>(key: TKey$1, queryOptions: ApiUseKeysetInfinitePrefetchQueryOptions<TQueryKeys, TKey$1, TErrorCode>) => {
-    execute: () => Promise<void>;
-  };
-  usePrefetchOffsetInfiniteQuery: <TKey$1 extends QueryKeysWithArrayEntityFromConfig<TQueryKeys>>(key: TKey$1, queryOptions: ApiUseOffsetInfinitePrefetchQueryOptions<TQueryKeys, TKey$1, TErrorCode>) => {
-    execute: () => Promise<void>;
-  };
-  usePrefetchQuery: <TKey$1 extends QueryKeysWithEntityFromConfig<TQueryKeys>>(key: TKey$1, queryOptions: ApiUsePrefetchQueryOptions<TQueryKeys, TKey$1, TErrorCode>) => {
-    execute: () => Promise<void>;
-  };
-  useQuery: <TKey$1 extends QueryKeysWithEntityFromConfig<TQueryKeys>>(key: TKey$1, queryOptions: ApiUseQueryOptions<TQueryKeys, TKey$1, TErrorCode>) => UseQueryReturnType<QueryKeyEntityFromConfig<TQueryKeys, TKey$1>, string>;
-};
-//#endregion
-//#region src/plugin/apiUtilsPlugin.d.ts
-/**
- * Create a Vue plugin that sets up TanStack Query and initializes API utilities.
- *
- * This plugin handles:
- * - Creating a QueryClient with the provided config
- * - Installing VueQueryPlugin on the app
- * - Initializing the global QueryClient for api-utils
- *
- * @example
- * ```typescript
- * import { apiUtilsPlugin } from '@wisemen/vue-core-api-utils'
- * import { vueQueryClientConfig } from '@wisemen/vue-core-configs'
- *
- * app.use(apiUtilsPlugin(vueQueryClientConfig()))
- * ```
- *
- * @param config - QueryClient configuration
- * @returns A Vue plugin that can be used with app.use()
- */
-declare function apiUtilsPlugin(config: QueryClientConfig): {
-  install: (app: App<any>) => void;
-};
-//#endregion
 //#region src/utils/sort/sort.utils.d.ts
 declare class SortUtil {
   static toDto<SortKey extends string, QueryKey>(sort: Sort<SortKey>[], sortKeyMap: Record<SortKey, QueryKey>): {
@@ -874,4 +847,4 @@ declare class SortUtil {
   }[];
 }
 //#endregion
-export { type ApiUnexpectedError, type ApiUnknownErrorObject, type ApiUseKeysetInfinitePrefetchQueryOptions, type ApiUseKeysetInfiniteQueryOptions, type ApiUseKeysetInfiniteQueryReturnType, type ApiUseMutationOptions, type ApiUseOffsetInfinitePrefetchQueryOptions, type ApiUseOffsetInfiniteQueryOptions, type ApiUseOffsetInfiniteQueryReturnType, type ApiUsePrefetchQueryOptions, type ApiUseQueryOptions, AsyncResult, AsyncResultErr, AsyncResultLoading, AsyncResultOk, type CreateApiInfiniteQueryUtilsReturnType, type CreateApiMutationUtilsReturnType, type CreateApiPrefetchInfiniteQueryUtilsReturnType, type CreateApiPrefetchQueryUtilsReturnType, type CreateApiQueryClientUtilsReturnType, type CreateApiQueryUtilsReturnType, type InfiniteQueryOptions, type KeysetInfiniteQueryOptions, type KeysetPagination, type KeysetPaginationParams, type KeysetPaginationResponse, type OffsetInfiniteQueryOptions, type OffsetPagination, type OffsetPaginationParams, type OffsetPaginationResponse, type PaginatedDataDto, QueryClient, type QueryClientUpdateOptions, type QueryClientUpdateResult, type QueryConfig, type QueryKeyArrayItemFromConfig, type QueryKeysWithArrayEntityFromConfig, type QueryParams, type Sort, SortDirection, SortUtil, type TanstackQueryClient, type UseKeysetInfiniteQueryReturnType, type UseMutationReturnType, type UseOffsetInfiniteQueryReturnType, type UseQueryOptions, type UseQueryReturnType, type WithFilterQuery, type WithSearchQuery, type WithSortQuery, type WithStaticFilterQuery, apiUtilsPlugin, createApiUtils, getQueryClient as getTanstackQueryClient, initializeApiUtils, setQueryConfig, type ApiError as "~ApiError", type ApiErrorObject as "~ApiErrorObject", type ApiExpectedError as "~ApiExpectedError", type ApiKnownErrorObject as "~ApiKnownErrorObject", type ApiResult as "~ApiResult", type AsyncApiResult as "~AsyncApiResult", type KeysetPaginationResult as "~KeysetPaginationResult", type OffsetPaginationResult as "~OffsetPaginationResult" };
+export { type ApiError, type ApiErrorObject, ApiErrorUtil, type ApiExpectedError, type ApiKnownErrorObject, type ApiResult, type ApiUnexpectedError, type ApiUnknownErrorObject, ApiUtil, type AsyncApiResult, AsyncResult, AsyncResultErr, AsyncResultLoading, AsyncResultOk, type InfiniteQueryOptions, type KeysetInfiniteQueryOptions, type KeysetPagination, type KeysetPaginationParams, type KeysetPaginationResponse, type KeysetPaginationResult, type OffsetInfiniteQueryOptions, type OffsetPagination, type OffsetPaginationParams, type OffsetPaginationResponse, type OffsetPaginationResult, type PaginatedDataDto, type PrefetchKeysetInfiniteQueryOptions, type PrefetchOffsetInfiniteQueryOptions, QueryClient, type QueryClientUpdateOptions, type QueryClientUpdateResult, type QueryConfig, type QueryParams, type Register, type RegisteredApiUseMutationOptions, type RegisteredErrorCodes, type RegisteredQueryKeyInput, type RegisteredQueryKeys, type Sort, SortDirection, SortUtil, type TanstackQueryClient, type UseKeysetInfiniteQueryReturnType, type UseMutationOptions, type UseMutationReturnType, type UseOffsetInfiniteQueryReturnType, type UseQueryOptions, type UseQueryReturnType, type WithFilterQuery, type WithSearchQuery, type WithSortQuery, type WithStaticFilterQuery, apiUtilsPlugin, getQueryClient as getTanstackQueryClient, initializeApiUtils, setQueryConfig, useKeysetInfiniteQuery, useMutation, useOffsetInfiniteQuery, usePrefetchKeysetInfiniteQuery, usePrefetchOffsetInfiniteQuery, usePrefetchQuery, useQuery };