@tanstack/angular-query-experimental 5.103.3 → 5.104.0

package/dist/create-base-query.d.mts

@@ -7,7 +7,7 @@ import { QueryKey, QueryObserver, QueryObserverResult } from "@tanstack/query-co
  * @param optionsFn
  * @param Observer
  */
-declare function createBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(optionsFn: () => CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver): MapToSignals<{
+export declare function createBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(optionsFn: () => CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver): MapToSignals<{
   refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<QueryObserverResult<TData, TError>>;
   data: TData;
   error: TError;
@@ -165,5 +165,4 @@ declare function createBaseQuery<TQueryFnData, TError, TData, TQueryData, TQuery
   fetchStatus: import("@tanstack/query-core").FetchStatus;
 }>;
 //#endregion
-export { createBaseQuery };
 //# sourceMappingURL=create-base-query.d.mts.map

package/dist/create-base-query.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"create-base-query.d.mts","names":["_$__signal_proxy0.MapToSignals"],"sources":["../src/create-base-query.ts"],"mappings":";;;;;;;;;iBA8BgB,gBACd,cACA,QACA,OACA,YACA,kBAAkB,UAElB,iBAAiB,uBACf,cACA,QACA,OACA,YACA,YAEF,iBAAiB"}
+{"version":3,"file":"create-base-query.d.mts","names":["_$__signal_proxy0.MapToSignals"],"sources":["../src/create-base-query.ts"],"mappings":";;;;;;;;;wBA8BgB,gBACd,cACA,QACA,OACA,YACA,kBAAkB,UAElB,iBAAiB,uBACf,cACA,QACA,OACA,YACA,YAEF,iBAAiB"}

package/dist/create-base-query.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-base-query.mjs","names":[],"sources":["../src/create-base-query.ts"],"sourcesContent":["import {\n  NgZone,\n  VERSION,\n  computed,\n  effect,\n  inject,\n  signal,\n  untracked,\n} from '@angular/core'\nimport {\n  QueryClient,\n  notifyManager,\n  shouldThrowError,\n} from '@tanstack/query-core'\nimport { signalProxy } from './signal-proxy'\nimport { injectIsRestoring } from './inject-is-restoring'\nimport { PENDING_TASKS } from './pending-tasks-compat'\nimport type { PendingTaskRef } from './pending-tasks-compat'\nimport type {\n  QueryKey,\n  QueryObserver,\n  QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { CreateBaseQueryOptions } from './types'\n\n/**\n * Base implementation for `injectQuery` and `injectInfiniteQuery`.\n * @param optionsFn\n * @param Observer\n */\nexport function createBaseQuery<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryData,\n  TQueryKey extends QueryKey,\n>(\n  optionsFn: () => CreateBaseQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  >,\n  Observer: typeof QueryObserver,\n) {\n  const ngZone = inject(NgZone)\n  const pendingTasks = inject(PENDING_TASKS)\n  const queryClient = inject(QueryClient)\n  const isRestoring = injectIsRestoring()\n\n  /**\n   * Signal that has the default options from query client applied\n   * computed() is used so signals can be inserted into the options\n   * making it reactive. Wrapping options in a function ensures embedded expressions\n   * are preserved and can keep being applied after signal changes\n   */\n  const defaultedOptionsSignal = computed(() => {\n    const defaultedOptions = queryClient.defaultQueryOptions(optionsFn())\n    defaultedOptions._optimisticResults = isRestoring()\n      ? 'isRestoring'\n      : 'optimistic'\n    return defaultedOptions\n  })\n\n  const observerSignal = (() => {\n    let instance: QueryObserver<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey\n    > | null = null\n\n    return computed(() => {\n      return (instance ||= new Observer(queryClient, defaultedOptionsSignal()))\n    })\n  })()\n\n  const optimisticResultSignal = computed(() =>\n    observerSignal().getOptimisticResult(defaultedOptionsSignal()),\n  )\n\n  const resultFromSubscriberSignal = signal<QueryObserverResult<\n    TData,\n    TError\n  > | null>(null)\n\n  effect(\n    (onCleanup) => {\n      const observer = observerSignal()\n      const defaultedOptions = defaultedOptionsSignal()\n\n      untracked(() => {\n        observer.setOptions(defaultedOptions)\n      })\n      onCleanup(() => {\n        ngZone.run(() => resultFromSubscriberSignal.set(null))\n      })\n    },\n    {\n      // Set allowSignalWrites to support Angular < v19\n      // Set to undefined to avoid warning on newer versions\n      allowSignalWrites: VERSION.major < '19' || undefined,\n    },\n  )\n\n  effect((onCleanup) => {\n    // observer.trackResult is not used as this optimization is not needed for Angular\n    const observer = observerSignal()\n    let pendingTaskRef: PendingTaskRef | null = null\n\n    const unsubscribe = isRestoring()\n      ? () => undefined\n      : untracked(() =>\n          ngZone.runOutsideAngular(() => {\n            return observer.subscribe(\n              notifyManager.batchCalls((state) => {\n                ngZone.run(() => {\n                  if (state.fetchStatus === 'fetching' && !pendingTaskRef) {\n                    pendingTaskRef = pendingTasks.add()\n                  }\n\n                  if (state.fetchStatus === 'idle' && pendingTaskRef) {\n                    pendingTaskRef()\n                    pendingTaskRef = null\n                  }\n\n                  if (\n                    state.isError &&\n                    !state.isFetching &&\n                    shouldThrowError(observer.options.throwOnError, [\n                      state.error,\n                      observer.getCurrentQuery(),\n                    ])\n                  ) {\n                    ngZone.onError.emit(state.error)\n                    throw state.error\n                  }\n                  resultFromSubscriberSignal.set(state)\n                })\n              }),\n            )\n          }),\n        )\n\n    onCleanup(() => {\n      if (pendingTaskRef) {\n        pendingTaskRef()\n        pendingTaskRef = null\n      }\n      unsubscribe()\n    })\n  })\n\n  return signalProxy(\n    computed(() => {\n      const subscriberResult = resultFromSubscriberSignal()\n      const optimisticResult = optimisticResultSignal()\n      const result = subscriberResult ?? optimisticResult\n\n      // Wrap methods to ensure observer has latest options before execution\n      const observer = observerSignal()\n\n      const originalRefetch = result.refetch\n      return {\n        ...result,\n        refetch: ((...args: Parameters<typeof originalRefetch>) => {\n          observer.setOptions(defaultedOptionsSignal())\n          return originalRefetch(...args)\n        }) as typeof originalRefetch,\n      }\n    }),\n  )\n}\n"],"mappings":";;;;;;;;;;;AA8BA,SAAgB,gBAOd,WAOA,UACA;CACA,MAAM,SAAS,OAAO,MAAM;CAC5B,MAAM,eAAe,OAAO,aAAa;CACzC,MAAM,cAAc,OAAO,WAAW;CACtC,MAAM,cAAc,kBAAkB;;;;;;;CAQtC,MAAM,yBAAyB,eAAe;EAC5C,MAAM,mBAAmB,YAAY,oBAAoB,UAAU,CAAC;EACpE,iBAAiB,qBAAqB,YAAY,IAC9C,gBACA;EACJ,OAAO;CACT,CAAC;CAED,MAAM,wBAAwB;EAC5B,IAAI,WAMO;EAEX,OAAO,eAAe;GACpB,OAAQ,aAAa,IAAI,SAAS,aAAa,uBAAuB,CAAC;EACzE,CAAC;CACH,EAAA,CAAG;CAEH,MAAM,yBAAyB,eAC7B,eAAe,CAAC,CAAC,oBAAoB,uBAAuB,CAAC,CAC/D;CAEA,MAAM,6BAA6B,OAGzB,IAAI;CAEd,QACG,cAAc;EACb,MAAM,WAAW,eAAe;EAChC,MAAM,mBAAmB,uBAAuB;EAEhD,gBAAgB;GACd,SAAS,WAAW,gBAAgB;EACtC,CAAC;EACD,gBAAgB;GACd,OAAO,UAAU,2BAA2B,IAAI,IAAI,CAAC;EACvD,CAAC;CACH,GACA,EAGE,mBAAmB,QAAQ,QAAQ,QAAQ,KAAA,EAC7C,CACF;CAEA,QAAQ,cAAc;EAEpB,MAAM,WAAW,eAAe;EAChC,IAAI,iBAAwC;EAE5C,MAAM,cAAc,YAAY,UACtB,KAAA,IACN,gBACE,OAAO,wBAAwB;GAC7B,OAAO,SAAS,UACd,cAAc,YAAY,UAAU;IAClC,OAAO,UAAU;KACf,IAAI,MAAM,gBAAgB,cAAc,CAAC,gBACvC,iBAAiB,aAAa,IAAI;KAGpC,IAAI,MAAM,gBAAgB,UAAU,gBAAgB;MAClD,eAAe;MACf,iBAAiB;KACnB;KAEA,IACE,MAAM,WACN,CAAC,MAAM,cACP,iBAAiB,SAAS,QAAQ,cAAc,CAC9C,MAAM,OACN,SAAS,gBAAgB,CAC3B,CAAC,GACD;MACA,OAAO,QAAQ,KAAK,MAAM,KAAK;MAC/B,MAAM,MAAM;KACd;KACA,2BAA2B,IAAI,KAAK;IACtC,CAAC;GACH,CAAC,CACH;EACF,CAAC,CACH;EAEJ,gBAAgB;GACd,IAAI,gBAAgB;IAClB,eAAe;IACf,iBAAiB;GACnB;GACA,YAAY;EACd,CAAC;CACH,CAAC;CAED,OAAO,YACL,eAAe;EACb,MAAM,mBAAmB,2BAA2B;EACpD,MAAM,mBAAmB,uBAAuB;EAChD,MAAM,SAAS,oBAAoB;EAGnC,MAAM,WAAW,eAAe;EAEhC,MAAM,kBAAkB,OAAO;EAC/B,OAAO;GACL,GAAG;GACH,WAAW,GAAG,SAA6C;IACzD,SAAS,WAAW,uBAAuB,CAAC;IAC5C,OAAO,gBAAgB,GAAG,IAAI;GAChC;EACF;CACF,CAAC,CACH;AACF"}
+{"version":3,"file":"create-base-query.mjs","names":[],"sources":["../src/create-base-query.ts"],"sourcesContent":["import {\n  NgZone,\n  VERSION,\n  computed,\n  effect,\n  inject,\n  signal,\n  untracked,\n} from '@angular/core'\nimport {\n  QueryClient,\n  notifyManager,\n  shouldThrowError,\n} from '@tanstack/query-core'\nimport { signalProxy } from './signal-proxy'\nimport { injectIsRestoring } from './inject-is-restoring'\nimport { PENDING_TASKS } from './pending-tasks-compat'\nimport type { PendingTaskRef } from './pending-tasks-compat'\nimport type {\n  QueryKey,\n  QueryObserver,\n  QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { CreateBaseQueryOptions } from './types'\n\n/**\n * Base implementation for `injectQuery` and `injectInfiniteQuery`.\n * @param optionsFn\n * @param Observer\n */\nexport function createBaseQuery<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryData,\n  TQueryKey extends QueryKey,\n>(\n  optionsFn: () => CreateBaseQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  >,\n  Observer: typeof QueryObserver,\n) {\n  const ngZone = inject(NgZone)\n  const pendingTasks = inject(PENDING_TASKS)\n  const queryClient = inject(QueryClient)\n  const isRestoring = injectIsRestoring()\n\n  /**\n   * Signal that has the default options from query client applied\n   * computed() is used so signals can be inserted into the options\n   * making it reactive. Wrapping options in a function ensures embedded expressions\n   * are preserved and can keep being applied after signal changes\n   */\n  const defaultedOptionsSignal = computed(() => {\n    const defaultedOptions = queryClient.defaultQueryOptions(optionsFn())\n    defaultedOptions._optimisticResults = isRestoring()\n      ? 'isRestoring'\n      : 'optimistic'\n    return defaultedOptions\n  })\n\n  const observerSignal = (() => {\n    let instance: QueryObserver<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey\n    > | null = null\n\n    return computed(() => {\n      return (instance ||= new Observer(queryClient, defaultedOptionsSignal()))\n    })\n  })()\n\n  const optimisticResultSignal = computed(() =>\n    observerSignal().getOptimisticResult(defaultedOptionsSignal()),\n  )\n\n  const resultFromSubscriberSignal = signal<QueryObserverResult<\n    TData,\n    TError\n  > | null>(null)\n\n  effect(\n    (onCleanup) => {\n      const observer = observerSignal()\n      const defaultedOptions = defaultedOptionsSignal()\n\n      untracked(() => {\n        observer.setOptions(defaultedOptions)\n      })\n      onCleanup(() => {\n        ngZone.run(() => resultFromSubscriberSignal.set(null))\n      })\n    },\n    {\n      // Set allowSignalWrites to support Angular < v19\n      // Set to undefined to avoid warning on newer versions\n      allowSignalWrites: VERSION.major < '19' || undefined,\n    },\n  )\n\n  effect((onCleanup) => {\n    // observer.trackResult is not used as this optimization is not needed for Angular\n    const observer = observerSignal()\n    let pendingTaskRef: PendingTaskRef | null = null\n\n    const unsubscribe = isRestoring()\n      ? () => undefined\n      : untracked(() =>\n          ngZone.runOutsideAngular(() => {\n            return observer.subscribe(\n              notifyManager.batchCalls((state) => {\n                ngZone.run(() => {\n                  if (state.fetchStatus === 'fetching' && !pendingTaskRef) {\n                    pendingTaskRef = pendingTasks.add()\n                  }\n\n                  if (state.fetchStatus === 'idle' && pendingTaskRef) {\n                    pendingTaskRef()\n                    pendingTaskRef = null\n                  }\n\n                  if (\n                    state.isError &&\n                    !state.isFetching &&\n                    shouldThrowError(observer.options.throwOnError, [\n                      state.error,\n                      observer.getCurrentQuery(),\n                    ])\n                  ) {\n                    ngZone.onError.emit(state.error)\n                    throw state.error\n                  }\n                  resultFromSubscriberSignal.set(state)\n                })\n              }),\n            )\n          }),\n        )\n\n    onCleanup(() => {\n      if (pendingTaskRef) {\n        pendingTaskRef()\n        pendingTaskRef = null\n      }\n      unsubscribe()\n    })\n  })\n\n  return signalProxy(\n    computed(() => {\n      const subscriberResult = resultFromSubscriberSignal()\n      const optimisticResult = optimisticResultSignal()\n      const result = subscriberResult ?? optimisticResult\n\n      // Wrap methods to ensure observer has latest options before execution\n      const observer = observerSignal()\n\n      const originalRefetch = result.refetch\n      return {\n        ...result,\n        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n        refetch: ((...args: Parameters<typeof originalRefetch>) => {\n          observer.setOptions(defaultedOptionsSignal())\n          return originalRefetch(...args)\n        }) as typeof originalRefetch,\n      }\n    }),\n  )\n}\n"],"mappings":";;;;;;;;;;;AA8BA,SAAgB,gBAOd,WAOA,UACA;CACA,MAAM,SAAS,OAAO,MAAM;CAC5B,MAAM,eAAe,OAAO,aAAa;CACzC,MAAM,cAAc,OAAO,WAAW;CACtC,MAAM,cAAc,kBAAkB;;;;;;;CAQtC,MAAM,yBAAyB,eAAe;EAC5C,MAAM,mBAAmB,YAAY,oBAAoB,UAAU,CAAC;EACpE,iBAAiB,qBAAqB,YAAY,IAC9C,gBACA;EACJ,OAAO;CACT,CAAC;CAED,MAAM,wBAAwB;EAC5B,IAAI,WAMO;EAEX,OAAO,eAAe;GACpB,OAAQ,aAAa,IAAI,SAAS,aAAa,uBAAuB,CAAC;EACzE,CAAC;CACH,EAAA,CAAG;CAEH,MAAM,yBAAyB,eAC7B,eAAe,CAAC,CAAC,oBAAoB,uBAAuB,CAAC,CAC/D;CAEA,MAAM,6BAA6B,OAGzB,IAAI;CAEd,QACG,cAAc;EACb,MAAM,WAAW,eAAe;EAChC,MAAM,mBAAmB,uBAAuB;EAEhD,gBAAgB;GACd,SAAS,WAAW,gBAAgB;EACtC,CAAC;EACD,gBAAgB;GACd,OAAO,UAAU,2BAA2B,IAAI,IAAI,CAAC;EACvD,CAAC;CACH,GACA,EAGE,mBAAmB,QAAQ,QAAQ,QAAQ,KAAA,EAC7C,CACF;CAEA,QAAQ,cAAc;EAEpB,MAAM,WAAW,eAAe;EAChC,IAAI,iBAAwC;EAE5C,MAAM,cAAc,YAAY,UACtB,KAAA,IACN,gBACE,OAAO,wBAAwB;GAC7B,OAAO,SAAS,UACd,cAAc,YAAY,UAAU;IAClC,OAAO,UAAU;KACf,IAAI,MAAM,gBAAgB,cAAc,CAAC,gBACvC,iBAAiB,aAAa,IAAI;KAGpC,IAAI,MAAM,gBAAgB,UAAU,gBAAgB;MAClD,eAAe;MACf,iBAAiB;KACnB;KAEA,IACE,MAAM,WACN,CAAC,MAAM,cACP,iBAAiB,SAAS,QAAQ,cAAc,CAC9C,MAAM,OACN,SAAS,gBAAgB,CAC3B,CAAC,GACD;MACA,OAAO,QAAQ,KAAK,MAAM,KAAK;MAC/B,MAAM,MAAM;KACd;KACA,2BAA2B,IAAI,KAAK;IACtC,CAAC;GACH,CAAC,CACH;EACF,CAAC,CACH;EAEJ,gBAAgB;GACd,IAAI,gBAAgB;IAClB,eAAe;IACf,iBAAiB;GACnB;GACA,YAAY;EACd,CAAC;CACH,CAAC;CAED,OAAO,YACL,eAAe;EACb,MAAM,mBAAmB,2BAA2B;EACpD,MAAM,mBAAmB,uBAAuB;EAChD,MAAM,SAAS,oBAAoB;EAGnC,MAAM,WAAW,eAAe;EAEhC,MAAM,kBAAkB,OAAO;EAC/B,OAAO;GACL,GAAG;GAEH,WAAW,GAAG,SAA6C;IACzD,SAAS,WAAW,uBAAuB,CAAC;IAC5C,OAAO,gBAAgB,GAAG,IAAI;GAChC;EACF;CACF,CAAC,CACH;AACF"}

package/dist/devtools/stub.d.mts

@@ -1,6 +1,5 @@
 import { WithDevtools } from "./types.mjs";
 //#region src/devtools/stub.d.ts
-declare const withDevtools: WithDevtools;
+export declare const withDevtools: WithDevtools;
 //#endregion
-export { withDevtools };
 //# sourceMappingURL=stub.d.mts.map

package/dist/devtools/stub.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"stub.d.mts","names":[],"sources":["../../src/devtools/stub.ts"],"mappings":";;cAGa,cAAc"}
+{"version":3,"file":"stub.d.mts","names":[],"sources":["../../src/devtools/stub.ts"],"mappings":";;qBAGa,cAAc"}

package/dist/devtools/types.d.mts

@@ -5,7 +5,7 @@ import { DevtoolsButtonPosition, DevtoolsErrorType, DevtoolsPosition, Theme } fr
 /**
  * Options for configuring withDevtools.
  */
-interface WithDevtoolsOptions {
+export interface WithDevtoolsOptions {
   /**
    * An array of dependencies to be injected and passed to the `withDevtoolsFn` function.
    *
@@ -33,7 +33,7 @@ interface WithDevtoolsOptions {
 /**
  * Options for configuring the TanStack Query devtools.
  */
-interface DevtoolsOptions {
+export interface DevtoolsOptions {
   /**
    * Set this true if you want the devtools to default to being open
    */
@@ -100,8 +100,7 @@ interface DevtoolsOptions {
    */
   loadDevtools?: 'auto' | boolean;
 }
-type WithDevtoolsFn = (...deps: Array<any>) => DevtoolsOptions;
-type WithDevtools = (withDevtoolsFn?: WithDevtoolsFn, options?: WithDevtoolsOptions) => DevtoolsFeature;
+export type WithDevtoolsFn = (...deps: Array<any>) => DevtoolsOptions;
+export type WithDevtools = (withDevtoolsFn?: WithDevtoolsFn, options?: WithDevtoolsOptions) => DevtoolsFeature;
 //#endregion
-export { DevtoolsOptions, WithDevtools, WithDevtoolsFn, WithDevtoolsOptions };
 //# sourceMappingURL=types.d.mts.map

package/dist/devtools/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/devtools/types.ts"],"mappings":";;;;;;;UAYiB;;;;;;;;;;;;;;;;;;;;;;;EAuBf,OAAO;;;;;UAMQ;;;;EAIf;;;;;;;EAOA,iBAAiB;;;;;;;EAOjB,WAAW;;;;EAIX,SAAS;;;;EAIT,aAAa,MAAM;;;;EAInB;;;;EAIA,kBAAkB;;;;EAIlB;;;;;;EAMA,QAAQ;;;;;;;;;;;;;;;;;;;;;EAsBR;;KAGU,qBAAqB,MAAM,eAAe;KAE1C,gBACV,iBAAiB,gBACjB,UAAU,wBACP"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/devtools/types.ts"],"mappings":";;;;;;;iBAYiB;;;;;;;;;;;;;;;;;;;;;;;EAuBf,OAAO;;;;;iBAMQ;;;;EAIf;;;;;;;EAOA,iBAAiB;;;;;;;EAOjB,WAAW;;;;EAIX,SAAS;;;;EAIT,aAAa,MAAM;;;;EAInB;;;;EAIA,kBAAkB;;;;EAIlB;;;;;;EAMA,QAAQ;;;;;;;;;;;;;;;;;;;;;EAsBR;;YAGU,qBAAqB,MAAM,eAAe;YAE1C,gBACV,iBAAiB,gBACjB,UAAU,wBACP"}

package/dist/devtools/with-devtools.d.mts

@@ -23,7 +23,6 @@ import { WithDevtools } from "./types.mjs";
  * @see {@link provideTanStackQuery}
  * @see {@link DevtoolsOptions}
  */
-declare const withDevtools: WithDevtools;
+export declare const withDevtools: WithDevtools;
 //#endregion
-export { withDevtools };
 //# sourceMappingURL=with-devtools.d.mts.map

package/dist/devtools/with-devtools.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"with-devtools.d.mts","names":[],"sources":["../../src/devtools/with-devtools.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;cA4Da,cAAc"}
+{"version":3,"file":"with-devtools.d.mts","names":[],"sources":["../../src/devtools/with-devtools.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;qBA4Da,cAAc"}

package/dist/devtools-panel/inject-devtools-panel.d.mts

@@ -12,7 +12,6 @@ import { InjectDevtoolsPanel } from "./types.mjs";
  * @returns DevtoolsPanelRef
  * @see https://tanstack.com/query/v5/docs/framework/angular/devtools
  */
-declare const injectDevtoolsPanel: InjectDevtoolsPanel;
+export declare const injectDevtoolsPanel: InjectDevtoolsPanel;
 //#endregion
-export { injectDevtoolsPanel };
 //# sourceMappingURL=inject-devtools-panel.d.mts.map

package/dist/devtools-panel/inject-devtools-panel.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"inject-devtools-panel.d.mts","names":[],"sources":["../../src/devtools-panel/inject-devtools-panel.ts"],"mappings":";;;;;;;;;;;;;;cAgCa,qBAAqB"}
+{"version":3,"file":"inject-devtools-panel.d.mts","names":[],"sources":["../../src/devtools-panel/inject-devtools-panel.ts"],"mappings":";;;;;;;;;;;;;;qBAgCa,qBAAqB"}

package/dist/devtools-panel/stub.d.mts

@@ -1,6 +1,5 @@
 import { InjectDevtoolsPanel } from "./types.mjs";
 //#region src/devtools-panel/stub.d.ts
-declare const injectDevtoolsPanel: InjectDevtoolsPanel;
+export declare const injectDevtoolsPanel: InjectDevtoolsPanel;
 //#endregion
-export { injectDevtoolsPanel };
 //# sourceMappingURL=stub.d.mts.map

package/dist/devtools-panel/stub.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"stub.d.mts","names":[],"sources":["../../src/devtools-panel/stub.ts"],"mappings":";;cAIa,qBAAqB"}
+{"version":3,"file":"stub.d.mts","names":[],"sources":["../../src/devtools-panel/stub.ts"],"mappings":";;qBAIa,qBAAqB"}

package/dist/devtools-panel/types.d.mts

@@ -2,7 +2,7 @@ import { ElementRef, Injector } from "@angular/core";
 import { QueryClient } from "@tanstack/query-core";
 import { DevtoolsErrorType } from "@tanstack/query-devtools";
 //#region src/devtools-panel/types.d.ts
-interface InjectDevtoolsPanelOptions {
+export interface InjectDevtoolsPanelOptions {
   /**
    * The `Injector` in which to create the devtools panel.
    *
@@ -13,13 +13,13 @@ interface InjectDevtoolsPanelOptions {
 /**
  * A devtools panel, which can be manually destroyed.
  */
-interface DevtoolsPanelRef {
+export interface DevtoolsPanelRef {
   /**
    * Destroy the panel, removing it from the DOM and stops listening to signal changes.
    */
   destroy: () => void;
 }
-interface DevtoolsPanelOptions {
+export interface DevtoolsPanelOptions {
   /**
    * Custom instance of QueryClient
    */
@@ -46,7 +46,6 @@ interface DevtoolsPanelOptions {
    */
   hostElement?: ElementRef;
 }
-type InjectDevtoolsPanel = (injectDevtoolsPanelFn: () => DevtoolsPanelOptions, options?: InjectDevtoolsPanelOptions) => DevtoolsPanelRef;
+export type InjectDevtoolsPanel = (injectDevtoolsPanelFn: () => DevtoolsPanelOptions, options?: InjectDevtoolsPanelOptions) => DevtoolsPanelRef;
 //#endregion
-export { DevtoolsPanelOptions, DevtoolsPanelRef, InjectDevtoolsPanel, InjectDevtoolsPanelOptions };
 //# sourceMappingURL=types.d.mts.map

package/dist/devtools-panel/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/devtools-panel/types.ts"],"mappings":";;;;UAIiB;;;;;;EAMf,WAAW;;;;;UAMI;;;;EAIf;;UAGe;;;;EAIf,SAAS;;;;EAIT,aAAa,MAAM;;;;EAInB;;;;EAIA,kBAAkB;;;;EAKlB;;;;;EAMA,cAAc;;KAGJ,uBACV,6BAA6B,sBAC7B,UAAU,+BACP"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/devtools-panel/types.ts"],"mappings":";;;;iBAIiB;;;;;;EAMf,WAAW;;;;;iBAMI;;;;EAIf;;iBAGe;;;;EAIf,SAAS;;;;EAIT,aAAa,MAAM;;;;EAInB;;;;EAIA,kBAAkB;;;;EAKlB;;;;;EAMA,cAAc;;YAGJ,uBACV,6BAA6B,sBAC7B,UAAU,+BACP"}

package/dist/infinite-query-options.d.mts

@@ -12,7 +12,7 @@ import { DefaultError, InfiniteData, InitialDataFunction, NonUndefinedGuard, Omi
  * @template TQueryKey - The type of your `queryKey`.
  * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.
  */
-type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+export type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
   /**
    * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
    * created or cached yet). If set to a function, the function will be called **once** during the shared/root
@@ -34,7 +34,7 @@ type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TD
  * @template TQueryKey - The type of your `queryKey`.
  * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.
  */
-type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = OmitKeyof<CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
+export type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = OmitKeyof<CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryFn'> & {
   /**
    * `skipToken` is not allowed as a value here — this overload is selected when no `initialData` is set. If
    * you don't intend to run the query yet, set `enabled: false` — omitting `queryFn` alone still triggers a
@@ -54,7 +54,7 @@ type UnusedSkipTokenInfiniteOptions<TQueryFnData, TError = DefaultError, TData =
  * @template TQueryKey - The type of your `queryKey`.
  * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.
  */
-type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+export type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
   /**
    * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
    * created or cached yet). If set to a function, the function will be called **once** during the shared/root
@@ -110,7 +110,7 @@ type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TDat
  * }
  * ```
  */
-declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
 /**
  * You can generally pass everything to `infiniteQueryOptions` that you can also pass to
  * `injectInfiniteQuery`. These options can be shared across functions and imperative APIs such as
@@ -162,7 +162,7 @@ declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData
  * @param options - The {@link UnusedSkipTokenInfiniteOptions} to use — everything you can pass to
  * `injectInfiniteQuery`.
  */
-declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
 /**
  * You can generally pass everything to `infiniteQueryOptions` that you can also pass to
  * `injectInfiniteQuery`. These options can be shared across functions and imperative APIs such as
@@ -214,7 +214,6 @@ declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData
  * @param options - The {@link UndefinedInitialDataInfiniteOptions} to use — everything you can pass to
  * `injectInfiniteQuery`.
  */
-declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
+export declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>;
 //#endregion
-export { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions, UnusedSkipTokenInfiniteOptions, infiniteQueryOptions };
 //# sourceMappingURL=infinite-query-options.d.mts.map

package/dist/infinite-query-options.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"infinite-query-options.d.mts","names":[],"sources":["../src/infinite-query-options.ts"],"mappings":";;;;;;;;;;;;;;KAuBY,oCACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,2BACF,cACA,QACA,OACA,WACA;;;;;;;;EASA,0BAEI,kBAAkB,aAAa,cAAc,eAC7C,oBACE,kBAAkB,aAAa,cAAc;;;;;;;;;;;;;;KAgBzC,+BACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,UACF,2BACE,cACA,QACA,OACA,WACA;;;;;;;EAUF,UAAU,QACR,2BACE,cACA,QACA,OACA,WACA,wBAEF;;;;;;;;;;;;;KAeQ,kCACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,2BACF,cACA,QACA,OACA,WACA;;;;;;;;EASA,aACI,kBAAkB,aAAa,cAAc,sBACtC,kBAAkB,aAAa,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkD1C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,kCACP,cACA,QACA,OACA,WACA,cAED,kCACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqD7C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,+BACP,cACA,QACA,OACA,WACA,cAED,+BACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqD7C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,oCACP,cACA,QACA,OACA,WACA,cAED,oCACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe"}
+{"version":3,"file":"infinite-query-options.d.mts","names":[],"sources":["../src/infinite-query-options.ts"],"mappings":";;;;;;;;;;;;;;YAuBY,oCACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,2BACF,cACA,QACA,OACA,WACA;;;;;;;;EASA,0BAEI,kBAAkB,aAAa,cAAc,eAC7C,oBACE,kBAAkB,aAAa,cAAc;;;;;;;;;;;;;;YAgBzC,+BACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,UACF,2BACE,cACA,QACA,OACA,WACA;;;;;;;EAUF,UAAU,QACR,2BACE,cACA,QACA,OACA,WACA,wBAEF;;;;;;;;;;;;;YAeQ,kCACV,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,wBACE,2BACF,cACA,QACA,OACA,WACA;;;;;;;;EASA,aACI,kBAAkB,aAAa,cAAc,sBACtC,kBAAkB,aAAa,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAkD1C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,kCACP,cACA,QACA,OACA,WACA,cAED,kCACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAqD7C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,+BACP,cACA,QACA,OACA,WACA,cAED,+BACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAqD7C,qBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,SAAS,oCACP,cACA,QACA,OACA,WACA,cAED,oCACD,cACA,QACA,OACA,WACA,cAEA,oBAAoB,WAAW,aAAa,eAAe"}

package/dist/inject-infinite-query.d.mts

@@ -3,7 +3,7 @@ import { DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions
 import { Injector } from "@angular/core";
 import { DefaultError, InfiniteData, QueryKey } from "@tanstack/query-core";
 //#region src/inject-infinite-query.d.ts
-interface InjectInfiniteQueryOptions {
+export interface InjectInfiniteQueryOptions {
   /**
    * The `Injector` in which to create the infinite query.
    *
@@ -60,7 +60,7 @@ interface InjectInfiniteQueryOptions {
  * }
  * ```
  */
-declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): DefinedCreateInfiniteQueryResult<TData, TError>;
+export declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): DefinedCreateInfiniteQueryResult<TData, TError>;
 /**
  * Injects an infinite query: a declarative dependency on an asynchronous source of data that is tied to a
  * unique key. Infinite queries can additively "load more" data onto an existing set of data, or
@@ -200,7 +200,7 @@ declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData
  * }
  * ```
  */
-declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): CreateInfiniteQueryResult<TData, TError>;
+export declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): CreateInfiniteQueryResult<TData, TError>;
 /**
  * This overload accepts the general {@link CreateInfiniteQueryOptions} shape rather than the
  * `initialData`-aware overloads above, so whether `data` is defined can't be inferred from the call site —
@@ -212,7 +212,6 @@ declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData
  * @param options - Additional configuration.
  * @returns The infinite query result.
  */
-declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): CreateInfiniteQueryResult<TData, TError>;
+export declare function injectInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(injectInfiniteQueryFn: () => CreateInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, options?: InjectInfiniteQueryOptions): CreateInfiniteQueryResult<TData, TError>;
 //#endregion
-export { InjectInfiniteQueryOptions, injectInfiniteQuery };
 //# sourceMappingURL=inject-infinite-query.d.mts.map

package/dist/inject-infinite-query.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"inject-infinite-query.d.mts","names":[],"sources":["../src/inject-infinite-query.ts"],"mappings":";;;;;UAwBiB;;;;;;EAMf,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoDG,oBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,6BAA6B,kCAC3B,cACA,QACA,OACA,WACA,aAEF,UAAU,6BACT,iCAAiC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6I3B,oBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,6BAA6B,oCAC3B,cACA,QACA,OACA,WACA,aAEF,UAAU,6BACT,0BAA0B,OAAO;;;;;;;;;;;;iBAapB,oBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,6BAA6B,2BAC3B,cACA,QACA,OACA,WACA,aAEF,UAAU,6BACT,0BAA0B,OAAO"}
+{"version":3,"file":"inject-infinite-query.d.mts","names":[],"sources":["../src/inject-infinite-query.ts"],"mappings":";;;;;iBAwBiB;;;;;;EAMf,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAoDG,oBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,6BAA6B,kCAC3B,cACA,QACA,OACA,WACA,aAEF,UAAU,6BACT,iCAAiC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6I3B,oBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,6BAA6B,oCAC3B,cACA,QACA,OACA,WACA,aAEF,UAAU,6BACT,0BAA0B,OAAO;;;;;;;;;;;;wBAapB,oBACd,cACA,SAAS,cACT,QAAQ,aAAa,eACrB,kBAAkB,WAAW,UAC7B,sBAEA,6BAA6B,2BAC3B,cACA,QACA,OACA,WACA,aAEF,UAAU,6BACT,0BAA0B,OAAO"}

package/dist/inject-is-fetching.d.mts

@@ -1,7 +1,7 @@
 import { Injector, Signal } from "@angular/core";
 import { QueryFilters } from "@tanstack/query-core";
 //#region src/inject-is-fetching.d.ts
-interface InjectIsFetchingOptions {
+export interface InjectIsFetchingOptions {
   /**
    * The `Injector` in which to create the isFetching signal.
    *
@@ -50,7 +50,6 @@ interface InjectIsFetchingOptions {
  * }
  * ```
  */
-declare function injectIsFetching(filters?: QueryFilters, options?: InjectIsFetchingOptions): Signal<number>;
+export declare function injectIsFetching(filters?: QueryFilters, options?: InjectIsFetchingOptions): Signal<number>;
 //#endregion
-export { InjectIsFetchingOptions, injectIsFetching };
 //# sourceMappingURL=inject-is-fetching.d.mts.map

package/dist/inject-is-fetching.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"inject-is-fetching.d.mts","names":[],"sources":["../src/inject-is-fetching.ts"],"mappings":";;;UAYiB;;;;;;EAMf,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4CG,iBACd,UAAU,cACV,UAAU,0BACT"}
+{"version":3,"file":"inject-is-fetching.d.mts","names":[],"sources":["../src/inject-is-fetching.ts"],"mappings":";;;iBAYiB;;;;;;EAMf,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA4CG,iBACd,UAAU,cACV,UAAU,0BACT"}

package/dist/inject-is-mutating.d.mts

@@ -1,7 +1,7 @@
 import { Injector, Signal } from "@angular/core";
 import { MutationFilters } from "@tanstack/query-core";
 //#region src/inject-is-mutating.d.ts
-interface InjectIsMutatingOptions {
+export interface InjectIsMutatingOptions {
   /**
    * The `Injector` in which to create the isMutating signal.
    *
@@ -33,7 +33,6 @@ interface InjectIsMutatingOptions {
  * }
  * ```
  */
-declare function injectIsMutating(filters?: MutationFilters, options?: InjectIsMutatingOptions): Signal<number>;
+export declare function injectIsMutating(filters?: MutationFilters, options?: InjectIsMutatingOptions): Signal<number>;
 //#endregion
-export { InjectIsMutatingOptions, injectIsMutating };
 //# sourceMappingURL=inject-is-mutating.d.mts.map

package/dist/inject-is-mutating.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"inject-is-mutating.d.mts","names":[],"sources":["../src/inject-is-mutating.ts"],"mappings":";;;UAYiB;;;;;;EAMf,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BG,iBACd,UAAU,iBACV,UAAU,0BACT"}
+{"version":3,"file":"inject-is-mutating.d.mts","names":[],"sources":["../src/inject-is-mutating.ts"],"mappings":";;;iBAYiB;;;;;;EAMf,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2BG,iBACd,UAAU,iBACV,UAAU,0BACT"}

package/dist/inject-is-restoring.d.mts

@@ -16,7 +16,7 @@ interface InjectIsRestoringOptions {
  * @returns A readonly `Signal<boolean>` — `true` while a restore is in progress, `false` otherwise (the
  * default when no `provideIsRestoring` provider is registered).
  */
-declare function injectIsRestoring(options?: InjectIsRestoringOptions): Signal<boolean>;
+export declare function injectIsRestoring(options?: InjectIsRestoringOptions): Signal<boolean>;
 /**
  * Registers a provider for the restore state read by `injectIsRestoring`. Wire this up wherever you drive a
  * restore yourself — e.g. a persist-client integration — so `injectQuery` and friends can defer subscribing
@@ -24,7 +24,6 @@ declare function injectIsRestoring(options?: InjectIsRestoringOptions): Signal<b
  * @param isRestoring - A readonly `Signal<boolean>` that tracks the restore state.
  * @returns A provider for the `isRestoring` signal.
  */
-declare function provideIsRestoring(isRestoring: Signal<boolean>): Provider;
+export declare function provideIsRestoring(isRestoring: Signal<boolean>): Provider;
 //#endregion
-export { injectIsRestoring, provideIsRestoring };
 //# sourceMappingURL=inject-is-restoring.d.mts.map

package/dist/inject-is-restoring.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"inject-is-restoring.d.mts","names":[],"sources":["../src/inject-is-restoring.ts"],"mappings":";;UAiBU;;;;;;EAMR,WAAW;;;;;;;;;;iBAWG,kBAAkB,UAAU,2BAAwB;;;;;;;;iBAapD,mBAAmB,aAAa,kBAAkB"}
+{"version":3,"file":"inject-is-restoring.d.mts","names":[],"sources":["../src/inject-is-restoring.ts"],"mappings":";;UAiBU;;;;;;EAMR,WAAW;;;;;;;;;;wBAWG,kBAAkB,UAAU,2BAAwB;;;;;;;;wBAapD,mBAAmB,aAAa,kBAAkB"}

package/dist/inject-mutation-state.d.mts

@@ -5,7 +5,7 @@ type MutationStateOptions<TResult = MutationState> = {
   filters?: MutationFilters;
   select?: (mutation: Mutation) => TResult;
 };
-interface InjectMutationStateOptions {
+export interface InjectMutationStateOptions {
   /**
    * The `Injector` in which to create the mutation state signal.
    *
@@ -70,7 +70,6 @@ interface InjectMutationStateOptions {
  * }
  * ```
  */
-declare function injectMutationState<TResult = MutationState>(injectMutationStateFn?: () => MutationStateOptions<TResult>, options?: InjectMutationStateOptions): Signal<Array<TResult>>;
+export declare function injectMutationState<TResult = MutationState>(injectMutationStateFn?: () => MutationStateOptions<TResult>, options?: InjectMutationStateOptions): Signal<Array<TResult>>;
 //#endregion
-export { InjectMutationStateOptions, injectMutationState };
 //# sourceMappingURL=inject-mutation-state.d.mts.map

package/dist/inject-mutation-state.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"inject-mutation-state.d.mts","names":[],"sources":["../src/inject-mutation-state.ts"],"mappings":";;;KAsBK,qBAAqB,UAAU;EAClC,UAAU;EACV,UAAU,UAAU,aAAa;;UAelB;;;;;;EAMf,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4DG,oBAAoB,UAAU,eAC5C,8BAA6B,qBAAqB,UAClD,UAAU,6BACT,OAAO,MAAM"}
+{"version":3,"file":"inject-mutation-state.d.mts","names":[],"sources":["../src/inject-mutation-state.ts"],"mappings":";;;KAsBK,qBAAqB,UAAU;EAClC,UAAU;EACV,UAAU,UAAU,aAAa;;iBAelB;;;;;;EAMf,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA4DG,oBAAoB,UAAU,eAC5C,8BAA6B,qBAAqB,UAClD,UAAU,6BACT,OAAO,MAAM"}

package/dist/inject-mutation.d.mts

@@ -2,7 +2,7 @@ import { CreateMutationOptions, CreateMutationResult } from "./types.mjs";
 import { Injector } from "@angular/core";
 import { DefaultError } from "@tanstack/query-core";
 //#region src/inject-mutation.d.ts
-interface InjectMutationOptions {
+export interface InjectMutationOptions {
   /**
    * The `Injector` in which to create the mutation.
    *
@@ -147,7 +147,6 @@ interface InjectMutationOptions {
  * }
  * ```
  */
-declare function injectMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(injectMutationFn: () => CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, options?: InjectMutationOptions): CreateMutationResult<TData, TError, TVariables, TOnMutateResult>;
+export declare function injectMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(injectMutationFn: () => CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, options?: InjectMutationOptions): CreateMutationResult<TData, TError, TVariables, TOnMutateResult>;
 //#endregion
-export { InjectMutationOptions, injectMutation };
 //# sourceMappingURL=inject-mutation.d.mts.map

package/dist/inject-mutation.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"inject-mutation.d.mts","names":[],"sources":["../src/inject-mutation.ts"],"mappings":";;;;UA2BiB;;;;;;EAMf,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4IG,eACd,iBACA,SAAS,cACT,mBACA,2BAEA,wBAAwB,sBACtB,OACA,QACA,YACA,kBAEF,UAAU,wBACT,qBAAqB,OAAO,QAAQ,YAAY"}
+{"version":3,"file":"inject-mutation.d.mts","names":[],"sources":["../src/inject-mutation.ts"],"mappings":";;;;iBA2BiB;;;;;;EAMf,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA4IG,eACd,iBACA,SAAS,cACT,mBACA,2BAEA,wBAAwB,sBACtB,OACA,QACA,YACA,kBAEF,UAAU,wBACT,qBAAqB,OAAO,QAAQ,YAAY"}

package/dist/inject-queries.d.mts

@@ -53,7 +53,7 @@ type GetCreateQueryResult<T> = T extends {
  * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not
  * meant to be set explicitly.
  */
-type QueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<QueryObserverOptionsForCreateQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetCreateQueryOptionsForCreateQueries<Head>] : T extends [infer Head, ...infer Tails] ? QueriesOptions<[...Tails], [...TResults, GetCreateQueryOptionsForCreateQueries<Head>], [...TDepth, 1]> : ReadonlyArray<unknown> extends T ? T : T extends Array<QueryObserverOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<QueryObserverOptionsForCreateQueries>;
+export type QueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<QueryObserverOptionsForCreateQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetCreateQueryOptionsForCreateQueries<Head>] : T extends [infer Head, ...infer Tails] ? QueriesOptions<[...Tails], [...TResults, GetCreateQueryOptionsForCreateQueries<Head>], [...TDepth, 1]> : ReadonlyArray<unknown> extends T ? T : T extends Array<QueryObserverOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<QueryObserverOptionsForCreateQueries>;
 /**
  * The result type returned by `injectQueries`, when no `combine` is provided. Mirrors {@link QueriesOptions}:
  * each tuple element's result type is inferred individually, up to 20 elements — past that, tuple recursion
@@ -66,8 +66,8 @@ type QueriesOptions<T extends Array<any>, TResults extends Array<any> = [], TDep
  * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not
  * meant to be set explicitly.
  */
-type QueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<CreateQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetCreateQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? QueriesResults<[...Tails], [...TResults, GetCreateQueryResult<Head>], [...TDepth, 1]> : { [K in keyof T]: GetCreateQueryResult<T[K]>; };
-interface InjectQueriesOptions<T extends Array<any>, TCombinedResult = QueriesResults<T>> {
+export type QueriesResults<T extends Array<any>, TResults extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<CreateQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResults, GetCreateQueryResult<Head>] : T extends [infer Head, ...infer Tails] ? QueriesResults<[...Tails], [...TResults, GetCreateQueryResult<Head>], [...TDepth, 1]> : { [K in keyof T]: GetCreateQueryResult<T[K]>; };
+export interface InjectQueriesOptions<T extends Array<any>, TCombinedResult = QueriesResults<T>> {
   queries: readonly [...QueriesOptions<T>] | readonly [...{ [K in keyof T]: GetCreateQueryOptionsForCreateQueries<T[K]>; }];
   combine?: (result: QueriesResults<T>) => TCombinedResult;
 }
@@ -205,7 +205,6 @@ interface InjectQueriesOptions<T extends Array<any>, TCombinedResult = QueriesRe
  * }
  * ```
  */
-declare function injectQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>(optionsFn: () => InjectQueriesOptions<T, TCombinedResult>, injector?: Injector): Signal<TCombinedResult>;
+export declare function injectQueries<T extends Array<any>, TCombinedResult = QueriesResults<T>>(optionsFn: () => InjectQueriesOptions<T, TCombinedResult>, injector?: Injector): Signal<TCombinedResult>;
 //#endregion
-export { InjectQueriesOptions, QueriesOptions, QueriesResults, injectQueries };
 //# sourceMappingURL=inject-queries.d.mts.map

package/dist/inject-queries.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"inject-queries.d.mts","names":[],"sources":["../src/inject-queries.ts"],"mappings":";;;;KAsCK,qCACH,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,UACF,mBAAmB,cAAc,QAAQ,OAAO;EAGhD,kBAAkB,eAAe,+BAA+B;;KAI7D;KAGA;KAEA,sCAAsC,KAEzC;EACE,mBAAmB;EACnB,cAAc;EACd,YAAY;IAEV,qCAAqC,cAAc,QAAQ,SAC3D;EAAY,mBAAmB;EAAc,cAAc;IACzD,qCAAqC,cAAc,UACnD;EAAY,YAAY;EAAO,cAAc;IAC3C,8CAA8C,QAAQ,SAEtD,iBAAiB,oBAAoB,cAAc,SACjD,qCAAqC,cAAc,QAAQ,SAC3D,iBAAiB,oBAAoB,UACnC,qCAAqC,cAAc,UACnD,iBAAiB,gBACf,qCAAqC,gBAErC;EACI,UACI,oBAAoB,oBAAoB,aACxC;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,qCACE,8BACgB,SAAS,eAAe,wBACxB,QAAQ,eAAe,OACvC,aAGF;KAGb,iCAAiC,GAAG,OAAO,oBAAoB;EAClE,oBAAoB;oBAEF,eACd,kBAAkB,OAAO,UACzB,qBAAqB,QACnB,yBAAyB,OAAO,UAChC,kCAAiC,sCACf,qBACd,kBAAkB,OAAO,UACzB,2BAA2B,QACzB,yBAAyB,OAAO,UAChC,kBAAkB,OAAO,UAC7B,kBAAkB,OAAO,UAC/B,kBAAkB,OAAO;KAExB,qBAAqB,KAExB;EAAY;EAAkB,cAAc;EAAQ,YAAY;IAC5D,iCAAiC,GAAG,OAAO,UAC3C;EAAY,mBAAmB;EAAc,cAAc;IACzD,iCAAiC,GAAG,cAAc,UAClD;EAAY,YAAY;EAAO,cAAc;IAC3C,iCAAiC,GAAG,OAAO,UAE3C,sBAAsB,cAAc,SAClC,iCAAiC,GAAG,OAAO,UAC3C,iBAAiB,oBAAoB,UACnC,iCAAiC,GAAG,cAAc,UAClD,iBAAiB,gBACf,iCAAiC,GAAG,gBAEpC;EACI,UACI,oBAAoB,qBACpB;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,iCACE,mBACgB,QAAQ,eAAe,uBACvB,SAAS,eAAe,UAG1C;;;;;;;;;;;;;;KAeN,eACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,wCACN,oBAEE,iBAAiB,YACX,UAAU,sCAAsC,SACpD,iBAAiB,eAAe,SAC9B,mBACM,YACA,UAAU,sCAAsC,YAChD,cAEN,+BAA+B,IAC7B,IAGA,UAAU,MACN,2CACQ,oBACA,cACA,aACA,cAGV,MACE,qCACE,cACA,QACA,OACA,cAIJ,MAAM;;;;;;;;;;;;;KAcR,eACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,qBACN,oBAEE,iBAAiB,YACX,UAAU,qBAAqB,SACnC,iBAAiB,eAAe,SAC9B,mBACM,YACA,UAAU,qBAAqB,YAC/B,iBAEH,WAAW,IAAI,qBAAqB,EAAE;UAElC,qBACf,UAAU,YACV,kBAAkB,eAAe;EAEjC,sBACiB,eAAe,sBAEpB,WAAW,IAAI,sCAAsC,EAAE;EAEnE,WAAW,QAAQ,eAAe,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyI3B,cACd,UAAU,YACV,kBAAkB,eAAe,IAEjC,iBAAiB,qBAAqB,GAAG,kBACzC,WAAW,WACV,OAAO"}
+{"version":3,"file":"inject-queries.d.mts","names":[],"sources":["../src/inject-queries.ts"],"mappings":";;;;KAsCK,qCACH,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,UACF,mBAAmB,cAAc,QAAQ,OAAO;EAGhD,kBAAkB,eAAe,+BAA+B;;KAI7D;KAGA;KAEA,sCAAsC,KAEzC;EACE,mBAAmB;EACnB,cAAc;EACd,YAAY;IAEV,qCAAqC,cAAc,QAAQ,SAC3D;EAAY,mBAAmB;EAAc,cAAc;IACzD,qCAAqC,cAAc,UACnD;EAAY,YAAY;EAAO,cAAc;IAC3C,8CAA8C,QAAQ,SAEtD,iBAAiB,oBAAoB,cAAc,SACjD,qCAAqC,cAAc,QAAQ,SAC3D,iBAAiB,oBAAoB,UACnC,qCAAqC,cAAc,UACnD,iBAAiB,gBACf,qCAAqC,gBAErC;EACI,UACI,oBAAoB,oBAAoB,aACxC;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,qCACE,8BACgB,SAAS,eAAe,wBACxB,QAAQ,eAAe,OACvC,aAGF;KAGb,iCAAiC,GAAG,OAAO,oBAAoB;EAClE,oBAAoB;oBAEF,eACd,kBAAkB,OAAO,UACzB,qBAAqB,QACnB,yBAAyB,OAAO,UAChC,kCAAiC,sCACf,qBACd,kBAAkB,OAAO,UACzB,2BAA2B,QACzB,yBAAyB,OAAO,UAChC,kBAAkB,OAAO,UAC7B,kBAAkB,OAAO,UAC/B,kBAAkB,OAAO;KAExB,qBAAqB,KAExB;EAAY;EAAkB,cAAc;EAAQ,YAAY;IAC5D,iCAAiC,GAAG,OAAO,UAC3C;EAAY,mBAAmB;EAAc,cAAc;IACzD,iCAAiC,GAAG,cAAc,UAClD;EAAY,YAAY;EAAO,cAAc;IAC3C,iCAAiC,GAAG,OAAO,UAE3C,sBAAsB,cAAc,SAClC,iCAAiC,GAAG,OAAO,UAC3C,iBAAiB,oBAAoB,UACnC,iCAAiC,GAAG,cAAc,UAClD,iBAAiB,gBACf,iCAAiC,GAAG,gBAEpC;EACI,UACI,oBAAoB,qBACpB;EACJ,UAAU,oBAAoB;EAC9B,eAAe,wBAAwB;IAEzC,iCACE,mBACgB,QAAQ,eAAe,uBACvB,SAAS,eAAe,UAG1C;;;;;;;;;;;;;;YAeN,eACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,wCACN,oBAEE,iBAAiB,YACX,UAAU,sCAAsC,SACpD,iBAAiB,eAAe,SAC9B,mBACM,YACA,UAAU,sCAAsC,YAChD,cAEN,+BAA+B,IAC7B,IAGA,UAAU,MACN,2CACQ,oBACA,cACA,aACA,cAGV,MACE,qCACE,cACA,QACA,OACA,cAIJ,MAAM;;;;;;;;;;;;;YAcR,eACV,UAAU,YACV,iBAAiB,iBACjB,eAAe,8BACb,yBAAyB,gBACzB,MAAM,qBACN,oBAEE,iBAAiB,YACX,UAAU,qBAAqB,SACnC,iBAAiB,eAAe,SAC9B,mBACM,YACA,UAAU,qBAAqB,YAC/B,iBAEH,WAAW,IAAI,qBAAqB,EAAE;iBAElC,qBACf,UAAU,YACV,kBAAkB,eAAe;EAEjC,sBACiB,eAAe,sBAEpB,WAAW,IAAI,sCAAsC,EAAE;EAEnE,WAAW,QAAQ,eAAe,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyI3B,cACd,UAAU,YACV,kBAAkB,eAAe,IAEjC,iBAAiB,qBAAqB,GAAG,kBACzC,WAAW,WACV,OAAO"}

package/dist/inject-queries.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"inject-queries.mjs","names":[],"sources":["../src/inject-queries.ts"],"sourcesContent":["import {\n  QueriesObserver,\n  QueryClient,\n  notifyManager,\n} from '@tanstack/query-core'\nimport {\n  DestroyRef,\n  Injector,\n  NgZone,\n  assertInInjectionContext,\n  computed,\n  effect,\n  inject,\n  runInInjectionContext,\n  signal,\n  untracked,\n} from '@angular/core'\nimport { signalProxy } from './signal-proxy'\nimport { injectIsRestoring } from './inject-is-restoring'\nimport type {\n  DefaultError,\n  OmitKeyof,\n  QueriesObserverOptions,\n  QueriesPlaceholderDataFunction,\n  QueryFunction,\n  QueryKey,\n  QueryObserverOptions,\n  ThrowOnError,\n} from '@tanstack/query-core'\nimport type {\n  CreateQueryOptions,\n  CreateQueryResult,\n  DefinedCreateQueryResult,\n} from './types'\nimport type { Signal } from '@angular/core'\n\n// This defines the `CreateQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.\n// `placeholderData` function always gets undefined passed\ntype QueryObserverOptionsForCreateQueries<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n  CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n  'placeholderData'\n> & {\n  placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>\n}\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForCreateQueries = symbol\n\ntype GetCreateQueryOptionsForCreateQueries<T> =\n  // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n  T extends {\n    queryFnData: infer TQueryFnData\n    error?: infer TError\n    data: infer TData\n  }\n    ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? QueryObserverOptionsForCreateQueries<unknown, TError, TData>\n        : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n          T extends [infer TQueryFnData, infer TError, infer TData]\n          ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData>\n          : T extends [infer TQueryFnData, infer TError]\n            ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? QueryObserverOptionsForCreateQueries<TQueryFnData>\n              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, infer TQueryKey>\n                      | SkipTokenForCreateQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? QueryObserverOptionsForCreateQueries<\n                    TQueryFnData,\n                    unknown extends TError ? DefaultError : TError,\n                    unknown extends TData ? TQueryFnData : TData,\n                    TQueryKey\n                  >\n                : // Fallback\n                  QueryObserverOptionsForCreateQueries\n\n// A defined initialData setting should return a DefinedCreateQueryResult rather than CreateQueryResult\ntype GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {\n  initialData?: infer TInitialData\n}\n  ? unknown extends TInitialData\n    ? CreateQueryResult<TData, TError>\n    : TInitialData extends TData\n      ? DefinedCreateQueryResult<TData, TError>\n      : TInitialData extends () => infer TInitialDataResult\n        ? unknown extends TInitialDataResult\n          ? CreateQueryResult<TData, TError>\n          : TInitialDataResult extends TData\n            ? DefinedCreateQueryResult<TData, TError>\n            : CreateQueryResult<TData, TError>\n        : CreateQueryResult<TData, TError>\n  : CreateQueryResult<TData, TError>\n\ntype GetCreateQueryResult<T> =\n  // Part 1: responsible for mapping explicit type parameter to function result, if object\n  T extends { queryFnData: any; error?: infer TError; data: infer TData }\n    ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n        : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n          T extends [any, infer TError, infer TData]\n          ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n          : T extends [infer TQueryFnData, infer TError]\n            ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData>\n              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, any>\n                      | SkipTokenForCreateQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? GetDefinedOrUndefinedQueryResult<\n                    T,\n                    unknown extends TData ? TQueryFnData : TData,\n                    unknown extends TError ? DefaultError : TError\n                  >\n                : // Fallback\n                  CreateQueryResult\n\n/**\n * The `queries` array accepted by `injectQueries`. Recursively unwraps each tuple element so every entry's\n * `queryFn`/`select`/`throwOnError` are inferred individually, up to 20 elements — past that, tuple\n * recursion falls back to a single homogeneous options type. An opaque array (e.g. `unknown[]`) is returned\n * as-is; a non-tuple array of a known element type is mapped to that element type instead, with no such\n * limit.\n *\n * @template T - The type of the `queries` array as written at the call site.\n * @template TResults - The internal accumulator that this type builds during recursion. It is not meant to\n * be set explicitly.\n * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not\n * meant to be set explicitly.\n */\nexport type QueriesOptions<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<QueryObserverOptionsForCreateQueries>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetCreateQueryOptionsForCreateQueries<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? QueriesOptions<\n            [...Tails],\n            [...TResults, GetCreateQueryOptionsForCreateQueries<Head>],\n            [...TDepth, 1]\n          >\n        : ReadonlyArray<unknown> extends T\n          ? T\n          : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n            // use this to infer the param types in the case of Array.map() argument\n            T extends Array<\n                QueryObserverOptionsForCreateQueries<\n                  infer TQueryFnData,\n                  infer TError,\n                  infer TData,\n                  infer TQueryKey\n                >\n              >\n            ? Array<\n                QueryObserverOptionsForCreateQueries<\n                  TQueryFnData,\n                  TError,\n                  TData,\n                  TQueryKey\n                >\n              >\n            : // Fallback\n              Array<QueryObserverOptionsForCreateQueries>\n\n/**\n * The result type returned by `injectQueries`, when no `combine` is provided. Mirrors {@link QueriesOptions}:\n * each tuple element's result type is inferred individually, up to 20 elements — past that, tuple recursion\n * falls back to a single homogeneous {@link CreateQueryResult} type. A non-tuple array is mapped per-element\n * instead, with no such limit — every entry keeps its individually inferred type regardless of array length.\n *\n * @template T - The type of the `queries` array, as inferred by {@link QueriesOptions}.\n * @template TResults - The internal accumulator that this type builds during recursion. It is not meant to\n * be set explicitly.\n * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not\n * meant to be set explicitly.\n */\nexport type QueriesResults<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<CreateQueryResult>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetCreateQueryResult<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? QueriesResults<\n            [...Tails],\n            [...TResults, GetCreateQueryResult<Head>],\n            [...TDepth, 1]\n          >\n        : { [K in keyof T]: GetCreateQueryResult<T[K]> }\n\nexport interface InjectQueriesOptions<\n  T extends Array<any>,\n  TCombinedResult = QueriesResults<T>,\n> {\n  queries:\n    | readonly [...QueriesOptions<T>]\n    | readonly [\n        ...{ [K in keyof T]: GetCreateQueryOptionsForCreateQueries<T[K]> },\n      ]\n  combine?: (result: QueriesResults<T>) => TCombinedResult\n}\n\n/**\n * Injects a signal to fetch a variable number of queries.\n *\n * The `queries` key accepts an array with query option objects mostly identical to `injectQuery`'s. Having\n * the same query key more than once in the array of query objects may cause some data to be shared between\n * queries. To avoid this, consider de-duplicating the queries and map the results back to the desired\n * structure.\n *\n * The `combine` option can be used to combine the results of the queries into a single value. The result\n * will be structurally shared to be as referentially stable as possible.\n *\n * @remarks Unlike `injectQuery`, `injectQueries` cannot infer the `data` argument of an _inline_ `select`\n * from its sibling `queryFn`. Because `injectQueries` infers the type of the whole `queries` array at once,\n * the `select` parameter of a query object written inline cannot be contextually typed from that same\n * object's `queryFn`, so it falls back to `unknown` — a\n * [known TypeScript limitation](https://github.com/TanStack/query/issues/6556). Annotate the `select`\n * parameter explicitly, or define the query with {@link queryOptions}, which resolves its types in a single\n * object _before_ it reaches `injectQueries`, to work around this — see the example below.\n * @param optionsFn - A function returning the queries' options — an array of query option objects under\n * `queries`, and an optional `combine`. Similar to `computed` from Angular, this function runs in the\n * reactive context, so signals read inside it (e.g. to build the `queries` array) drive the queries.\n * @param injector - The `Injector` in which to create the queries. If this is not provided, the current\n * injection context will be used instead (via `inject`).\n * @returns A `Signal` with the combined result. Without `combine`, this is an array with all the query\n * results, in the same order as the input. When `combine` is provided, this is the value returned by\n * `combine` instead.\n *\n * @example\n * ```angular-ts\n * @Component({\n *   selector: 'posts',\n *   template: `\n *     <ul>\n *       @for (query of postQueries(); track $index) {\n *         @if (query.isPending()) {\n *           <li>Loading...</li>\n *         } @else if (query.isError()) {\n *           <li>Error: {{ query.error()?.message }}</li>\n *         } @else {\n *           <li>{{ query.data().title }}</li>\n *         }\n *       }\n *     </ul>\n *   `,\n * })\n * export class Posts {\n *   readonly ids = signal([1, 2, 3])\n *\n *   readonly postQueries = injectQueries(() => ({\n *     queries: this.ids().map((id) => ({\n *       queryKey: ['post', id],\n *       queryFn: () => fetchPost(id),\n *       staleTime: Infinity,\n *     })),\n *   }))\n * }\n * ```\n *\n * @example\n * Combining results into a single value:\n * ```angular-ts\n * @Component({\n *   selector: 'posts',\n *   template: `\n *     @if (combined().isPending) {\n *       Loading...\n *     } @else if (combined().isError) {\n *       Error loading posts\n *     } @else {\n *       <ul>\n *         @for (post of combined().data; track post?.id) {\n *           <li>{{ post?.title }}</li>\n *         }\n *       </ul>\n *     }\n *   `,\n * })\n * export class Posts {\n *   readonly ids = signal([1, 2, 3])\n *\n *   readonly combined = injectQueries(() => ({\n *     queries: this.ids().map((id) => ({\n *       queryKey: ['post', id],\n *       queryFn: () => fetchPost(id),\n *     })),\n *     combine: (postQueries) => ({\n *       data: postQueries.map((query) => query.data),\n *       isPending: postQueries.some((query) => query.isPending),\n *       isError: postQueries.some((query) => query.isError),\n *     }),\n *   }))\n * }\n * ```\n *\n * @example\n * Typing `select` via {@link queryOptions}. Note that spreading a `queryOptions` result and overriding\n * `select` inline still falls back to `unknown` — wrap the spread in `queryOptions` again so the override is\n * resolved before it reaches `injectQueries`:\n * ```angular-ts\n * const postOptions = (id: number) =>\n *   queryOptions({\n *     queryKey: ['post', id],\n *     queryFn: () => fetchPost(id),\n *   })\n *\n * @Component({\n *   selector: 'post-title',\n *   template: `<h1>{{ fixed()[0].data() }}</h1>`,\n * })\n * export class PostTitle {\n *   readonly id = signal(1)\n *\n *   readonly broken = injectQueries(() => ({\n *     queries: [\n *       {\n *         ...postOptions(this.id()),\n *         // ❌ `data` is `unknown` here\n *         select: (data) => data.title,\n *       },\n *     ],\n *   }))\n *\n *   readonly fixed = injectQueries(() => ({\n *     queries: [\n *       queryOptions({\n *         ...postOptions(this.id()),\n *         // ✅ `data` is `Post`\n *         select: (data) => data.title,\n *       }),\n *     ],\n *   }))\n * }\n * ```\n */\nexport function injectQueries<\n  T extends Array<any>,\n  TCombinedResult = QueriesResults<T>,\n>(\n  optionsFn: () => InjectQueriesOptions<T, TCombinedResult>,\n  injector?: Injector,\n): Signal<TCombinedResult> {\n  !injector && assertInInjectionContext(injectQueries)\n  return runInInjectionContext(injector ?? inject(Injector), () => {\n    const destroyRef = inject(DestroyRef)\n    const ngZone = inject(NgZone)\n    const queryClient = inject(QueryClient)\n    const isRestoring = injectIsRestoring()\n\n    /**\n     * Signal that has the default options from query client applied\n     * computed() is used so signals can be inserted into the options\n     * making it reactive. Wrapping options in a function ensures embedded expressions\n     * are preserved and can keep being applied after signal changes\n     */\n    const optionsSignal = computed(() => {\n      return optionsFn()\n    })\n\n    const defaultedQueries = computed(() => {\n      return optionsSignal().queries.map((opts) => {\n        const defaultedOptions = queryClient.defaultQueryOptions(\n          opts as QueryObserverOptions,\n        )\n        // Make sure the results are already in fetching state before subscribing or updating options\n        defaultedOptions._optimisticResults = isRestoring()\n          ? 'isRestoring'\n          : 'optimistic'\n\n        return defaultedOptions as QueryObserverOptions\n      })\n    })\n\n    const observerSignal = (() => {\n      let instance: QueriesObserver<TCombinedResult> | null = null\n\n      return computed(() => {\n        return (instance ||= new QueriesObserver<TCombinedResult>(\n          queryClient,\n          defaultedQueries(),\n          optionsSignal() as QueriesObserverOptions<TCombinedResult>,\n        ))\n      })\n    })()\n\n    const optimisticResultSignal = computed(() =>\n      observerSignal().getOptimisticResult(\n        defaultedQueries(),\n        (optionsSignal() as QueriesObserverOptions<TCombinedResult>).combine,\n      ),\n    )\n\n    // Do not notify on updates because of changes in the options because\n    // these changes should already be reflected in the optimistic result.\n    effect(() => {\n      observerSignal().setQueries(\n        defaultedQueries(),\n        optionsSignal() as QueriesObserverOptions<TCombinedResult>,\n      )\n    })\n\n    const optimisticCombinedResultSignal = computed(() => {\n      const [_optimisticResult, getCombinedResult, trackResult] =\n        optimisticResultSignal()\n      return getCombinedResult(trackResult())\n    })\n\n    const resultFromSubscriberSignal = signal<TCombinedResult | null>(null)\n\n    effect(() => {\n      const observer = observerSignal()\n      const [_optimisticResult, getCombinedResult] = optimisticResultSignal()\n\n      untracked(() => {\n        const unsubscribe = isRestoring()\n          ? () => undefined\n          : ngZone.runOutsideAngular(() =>\n              observer.subscribe(\n                notifyManager.batchCalls((state) => {\n                  resultFromSubscriberSignal.set(getCombinedResult(state))\n                }),\n              ),\n            )\n\n        destroyRef.onDestroy(unsubscribe)\n      })\n    })\n\n    const resultSignal = computed(() => {\n      const subscriberResult = resultFromSubscriberSignal()\n      const optimisticResult = optimisticCombinedResultSignal()\n      return subscriberResult ?? optimisticResult\n    })\n\n    return computed(() => {\n      const result = resultSignal()\n      const { combine } = optionsSignal()\n\n      return combine\n        ? result\n        : (result as QueriesResults<T>).map((query) =>\n            signalProxy(signal(query)),\n          )\n    })\n  }) as unknown as Signal<TCombinedResult>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgXA,SAAgB,cAId,WACA,UACyB;CACzB,CAAC,YAAY,yBAAyB,aAAa;CACnD,OAAO,sBAAsB,YAAY,OAAO,QAAQ,SAAS;EAC/D,MAAM,aAAa,OAAO,UAAU;EACpC,MAAM,SAAS,OAAO,MAAM;EAC5B,MAAM,cAAc,OAAO,WAAW;EACtC,MAAM,cAAc,kBAAkB;;;;;;;EAQtC,MAAM,gBAAgB,eAAe;GACnC,OAAO,UAAU;EACnB,CAAC;EAED,MAAM,mBAAmB,eAAe;GACtC,OAAO,cAAc,CAAC,CAAC,QAAQ,KAAK,SAAS;IAC3C,MAAM,mBAAmB,YAAY,oBACnC,IACF;IAEA,iBAAiB,qBAAqB,YAAY,IAC9C,gBACA;IAEJ,OAAO;GACT,CAAC;EACH,CAAC;EAED,MAAM,wBAAwB;GAC5B,IAAI,WAAoD;GAExD,OAAO,eAAe;IACpB,OAAQ,aAAa,IAAI,gBACvB,aACA,iBAAiB,GACjB,cAAc,CAChB;GACF,CAAC;EACH,EAAA,CAAG;EAEH,MAAM,yBAAyB,eAC7B,eAAe,CAAC,CAAC,oBACf,iBAAiB,GAChB,cAAc,CAAC,CAA6C,OAC/D,CACF;EAIA,aAAa;GACX,eAAe,CAAC,CAAC,WACf,iBAAiB,GACjB,cAAc,CAChB;EACF,CAAC;EAED,MAAM,iCAAiC,eAAe;GACpD,MAAM,CAAC,mBAAmB,mBAAmB,eAC3C,uBAAuB;GACzB,OAAO,kBAAkB,YAAY,CAAC;EACxC,CAAC;EAED,MAAM,6BAA6B,OAA+B,IAAI;EAEtE,aAAa;GACX,MAAM,WAAW,eAAe;GAChC,MAAM,CAAC,mBAAmB,qBAAqB,uBAAuB;GAEtE,gBAAgB;IACd,MAAM,cAAc,YAAY,UACtB,KAAA,IACN,OAAO,wBACL,SAAS,UACP,cAAc,YAAY,UAAU;KAClC,2BAA2B,IAAI,kBAAkB,KAAK,CAAC;IACzD,CAAC,CACH,CACF;IAEJ,WAAW,UAAU,WAAW;GAClC,CAAC;EACH,CAAC;EAED,MAAM,eAAe,eAAe;GAClC,MAAM,mBAAmB,2BAA2B;GACpD,MAAM,mBAAmB,+BAA+B;GACxD,OAAO,oBAAoB;EAC7B,CAAC;EAED,OAAO,eAAe;GACpB,MAAM,SAAS,aAAa;GAC5B,MAAM,EAAE,YAAY,cAAc;GAElC,OAAO,UACH,SACC,OAA6B,KAAK,UACjC,YAAY,OAAO,KAAK,CAAC,CAC3B;EACN,CAAC;CACH,CAAC;AACH"}
+{"version":3,"file":"inject-queries.mjs","names":[],"sources":["../src/inject-queries.ts"],"sourcesContent":["import {\n  QueriesObserver,\n  QueryClient,\n  notifyManager,\n} from '@tanstack/query-core'\nimport {\n  DestroyRef,\n  Injector,\n  NgZone,\n  assertInInjectionContext,\n  computed,\n  effect,\n  inject,\n  runInInjectionContext,\n  signal,\n  untracked,\n} from '@angular/core'\nimport { signalProxy } from './signal-proxy'\nimport { injectIsRestoring } from './inject-is-restoring'\nimport type {\n  DefaultError,\n  OmitKeyof,\n  QueriesObserverOptions,\n  QueriesPlaceholderDataFunction,\n  QueryFunction,\n  QueryKey,\n  QueryObserverOptions,\n  ThrowOnError,\n} from '@tanstack/query-core'\nimport type {\n  CreateQueryOptions,\n  CreateQueryResult,\n  DefinedCreateQueryResult,\n} from './types'\nimport type { Signal } from '@angular/core'\n\n// This defines the `CreateQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.\n// `placeholderData` function always gets undefined passed\ntype QueryObserverOptionsForCreateQueries<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n  CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n  'placeholderData'\n> & {\n  placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>\n}\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForCreateQueries = symbol\n\ntype GetCreateQueryOptionsForCreateQueries<T> =\n  // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n  T extends {\n    queryFnData: infer TQueryFnData\n    error?: infer TError\n    data: infer TData\n  }\n    ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? QueryObserverOptionsForCreateQueries<unknown, TError, TData>\n        : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n          T extends [infer TQueryFnData, infer TError, infer TData]\n          ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError, TData>\n          : T extends [infer TQueryFnData, infer TError]\n            ? QueryObserverOptionsForCreateQueries<TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? QueryObserverOptionsForCreateQueries<TQueryFnData>\n              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, infer TQueryKey>\n                      | SkipTokenForCreateQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? QueryObserverOptionsForCreateQueries<\n                    TQueryFnData,\n                    unknown extends TError ? DefaultError : TError,\n                    unknown extends TData ? TQueryFnData : TData,\n                    TQueryKey\n                  >\n                : // Fallback\n                  QueryObserverOptionsForCreateQueries\n\n// A defined initialData setting should return a DefinedCreateQueryResult rather than CreateQueryResult\ntype GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {\n  initialData?: infer TInitialData\n}\n  ? unknown extends TInitialData\n    ? CreateQueryResult<TData, TError>\n    : TInitialData extends TData\n      ? DefinedCreateQueryResult<TData, TError>\n      : TInitialData extends () => infer TInitialDataResult\n        ? unknown extends TInitialDataResult\n          ? CreateQueryResult<TData, TError>\n          : TInitialDataResult extends TData\n            ? DefinedCreateQueryResult<TData, TError>\n            : CreateQueryResult<TData, TError>\n        : CreateQueryResult<TData, TError>\n  : CreateQueryResult<TData, TError>\n\ntype GetCreateQueryResult<T> =\n  // Part 1: responsible for mapping explicit type parameter to function result, if object\n  T extends { queryFnData: any; error?: infer TError; data: infer TData }\n    ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n      ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n      : T extends { data: infer TData; error?: infer TError }\n        ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n        : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n          T extends [any, infer TError, infer TData]\n          ? GetDefinedOrUndefinedQueryResult<T, TData, TError>\n          : T extends [infer TQueryFnData, infer TError]\n            ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>\n            : T extends [infer TQueryFnData]\n              ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData>\n              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n                T extends {\n                    queryFn?:\n                      | QueryFunction<infer TQueryFnData, any>\n                      | SkipTokenForCreateQueries\n                    select?: (data: any) => infer TData\n                    throwOnError?: ThrowOnError<any, infer TError, any, any>\n                  }\n                ? GetDefinedOrUndefinedQueryResult<\n                    T,\n                    unknown extends TData ? TQueryFnData : TData,\n                    unknown extends TError ? DefaultError : TError\n                  >\n                : // Fallback\n                  CreateQueryResult\n\n/**\n * The `queries` array accepted by `injectQueries`. Recursively unwraps each tuple element so every entry's\n * `queryFn`/`select`/`throwOnError` are inferred individually, up to 20 elements — past that, tuple\n * recursion falls back to a single homogeneous options type. An opaque array (e.g. `unknown[]`) is returned\n * as-is; a non-tuple array of a known element type is mapped to that element type instead, with no such\n * limit.\n *\n * @template T - The type of the `queries` array as written at the call site.\n * @template TResults - The internal accumulator that this type builds during recursion. It is not meant to\n * be set explicitly.\n * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not\n * meant to be set explicitly.\n */\nexport type QueriesOptions<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<QueryObserverOptionsForCreateQueries>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetCreateQueryOptionsForCreateQueries<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? QueriesOptions<\n            [...Tails],\n            [...TResults, GetCreateQueryOptionsForCreateQueries<Head>],\n            [...TDepth, 1]\n          >\n        : ReadonlyArray<unknown> extends T\n          ? T\n          : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogeneous type!\n            // use this to infer the param types in the case of Array.map() argument\n            T extends Array<\n                QueryObserverOptionsForCreateQueries<\n                  infer TQueryFnData,\n                  infer TError,\n                  infer TData,\n                  infer TQueryKey\n                >\n              >\n            ? Array<\n                QueryObserverOptionsForCreateQueries<\n                  TQueryFnData,\n                  TError,\n                  TData,\n                  TQueryKey\n                >\n              >\n            : // Fallback\n              Array<QueryObserverOptionsForCreateQueries>\n\n/**\n * The result type returned by `injectQueries`, when no `combine` is provided. Mirrors {@link QueriesOptions}:\n * each tuple element's result type is inferred individually, up to 20 elements — past that, tuple recursion\n * falls back to a single homogeneous {@link CreateQueryResult} type. A non-tuple array is mapped per-element\n * instead, with no such limit — every entry keeps its individually inferred type regardless of array length.\n *\n * @template T - The type of the `queries` array, as inferred by {@link QueriesOptions}.\n * @template TResults - The internal accumulator that this type builds during recursion. It is not meant to\n * be set explicitly.\n * @template TDepth - The internal recursion-depth counter, checked against the 20-element limit. It is not\n * meant to be set explicitly.\n */\nexport type QueriesResults<\n  T extends Array<any>,\n  TResults extends Array<any> = [],\n  TDepth extends ReadonlyArray<number> = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n  ? Array<CreateQueryResult>\n  : T extends []\n    ? []\n    : T extends [infer Head]\n      ? [...TResults, GetCreateQueryResult<Head>]\n      : T extends [infer Head, ...infer Tails]\n        ? QueriesResults<\n            [...Tails],\n            [...TResults, GetCreateQueryResult<Head>],\n            [...TDepth, 1]\n          >\n        : { [K in keyof T]: GetCreateQueryResult<T[K]> }\n\nexport interface InjectQueriesOptions<\n  T extends Array<any>,\n  TCombinedResult = QueriesResults<T>,\n> {\n  queries:\n    | readonly [...QueriesOptions<T>]\n    | readonly [\n        ...{ [K in keyof T]: GetCreateQueryOptionsForCreateQueries<T[K]> },\n      ]\n  combine?: (result: QueriesResults<T>) => TCombinedResult\n}\n\n/**\n * Injects a signal to fetch a variable number of queries.\n *\n * The `queries` key accepts an array with query option objects mostly identical to `injectQuery`'s. Having\n * the same query key more than once in the array of query objects may cause some data to be shared between\n * queries. To avoid this, consider de-duplicating the queries and map the results back to the desired\n * structure.\n *\n * The `combine` option can be used to combine the results of the queries into a single value. The result\n * will be structurally shared to be as referentially stable as possible.\n *\n * @remarks Unlike `injectQuery`, `injectQueries` cannot infer the `data` argument of an _inline_ `select`\n * from its sibling `queryFn`. Because `injectQueries` infers the type of the whole `queries` array at once,\n * the `select` parameter of a query object written inline cannot be contextually typed from that same\n * object's `queryFn`, so it falls back to `unknown` — a\n * [known TypeScript limitation](https://github.com/TanStack/query/issues/6556). Annotate the `select`\n * parameter explicitly, or define the query with {@link queryOptions}, which resolves its types in a single\n * object _before_ it reaches `injectQueries`, to work around this — see the example below.\n * @param optionsFn - A function returning the queries' options — an array of query option objects under\n * `queries`, and an optional `combine`. Similar to `computed` from Angular, this function runs in the\n * reactive context, so signals read inside it (e.g. to build the `queries` array) drive the queries.\n * @param injector - The `Injector` in which to create the queries. If this is not provided, the current\n * injection context will be used instead (via `inject`).\n * @returns A `Signal` with the combined result. Without `combine`, this is an array with all the query\n * results, in the same order as the input. When `combine` is provided, this is the value returned by\n * `combine` instead.\n *\n * @example\n * ```angular-ts\n * @Component({\n *   selector: 'posts',\n *   template: `\n *     <ul>\n *       @for (query of postQueries(); track $index) {\n *         @if (query.isPending()) {\n *           <li>Loading...</li>\n *         } @else if (query.isError()) {\n *           <li>Error: {{ query.error()?.message }}</li>\n *         } @else {\n *           <li>{{ query.data().title }}</li>\n *         }\n *       }\n *     </ul>\n *   `,\n * })\n * export class Posts {\n *   readonly ids = signal([1, 2, 3])\n *\n *   readonly postQueries = injectQueries(() => ({\n *     queries: this.ids().map((id) => ({\n *       queryKey: ['post', id],\n *       queryFn: () => fetchPost(id),\n *       staleTime: Infinity,\n *     })),\n *   }))\n * }\n * ```\n *\n * @example\n * Combining results into a single value:\n * ```angular-ts\n * @Component({\n *   selector: 'posts',\n *   template: `\n *     @if (combined().isPending) {\n *       Loading...\n *     } @else if (combined().isError) {\n *       Error loading posts\n *     } @else {\n *       <ul>\n *         @for (post of combined().data; track post?.id) {\n *           <li>{{ post?.title }}</li>\n *         }\n *       </ul>\n *     }\n *   `,\n * })\n * export class Posts {\n *   readonly ids = signal([1, 2, 3])\n *\n *   readonly combined = injectQueries(() => ({\n *     queries: this.ids().map((id) => ({\n *       queryKey: ['post', id],\n *       queryFn: () => fetchPost(id),\n *     })),\n *     combine: (postQueries) => ({\n *       data: postQueries.map((query) => query.data),\n *       isPending: postQueries.some((query) => query.isPending),\n *       isError: postQueries.some((query) => query.isError),\n *     }),\n *   }))\n * }\n * ```\n *\n * @example\n * Typing `select` via {@link queryOptions}. Note that spreading a `queryOptions` result and overriding\n * `select` inline still falls back to `unknown` — wrap the spread in `queryOptions` again so the override is\n * resolved before it reaches `injectQueries`:\n * ```angular-ts\n * const postOptions = (id: number) =>\n *   queryOptions({\n *     queryKey: ['post', id],\n *     queryFn: () => fetchPost(id),\n *   })\n *\n * @Component({\n *   selector: 'post-title',\n *   template: `<h1>{{ fixed()[0].data() }}</h1>`,\n * })\n * export class PostTitle {\n *   readonly id = signal(1)\n *\n *   readonly broken = injectQueries(() => ({\n *     queries: [\n *       {\n *         ...postOptions(this.id()),\n *         // ❌ `data` is `unknown` here\n *         select: (data) => data.title,\n *       },\n *     ],\n *   }))\n *\n *   readonly fixed = injectQueries(() => ({\n *     queries: [\n *       queryOptions({\n *         ...postOptions(this.id()),\n *         // ✅ `data` is `Post`\n *         select: (data) => data.title,\n *       }),\n *     ],\n *   }))\n * }\n * ```\n */\nexport function injectQueries<\n  T extends Array<any>,\n  TCombinedResult = QueriesResults<T>,\n>(\n  optionsFn: () => InjectQueriesOptions<T, TCombinedResult>,\n  injector?: Injector,\n): Signal<TCombinedResult> {\n  !injector && assertInInjectionContext(injectQueries)\n  return runInInjectionContext(injector ?? inject(Injector), () => {\n    const destroyRef = inject(DestroyRef)\n    const ngZone = inject(NgZone)\n    const queryClient = inject(QueryClient)\n    const isRestoring = injectIsRestoring()\n\n    /**\n     * Signal that has the default options from query client applied\n     * computed() is used so signals can be inserted into the options\n     * making it reactive. Wrapping options in a function ensures embedded expressions\n     * are preserved and can keep being applied after signal changes\n     */\n    const optionsSignal = computed(() => {\n      return optionsFn()\n    })\n\n    const defaultedQueries = computed(() => {\n      return optionsSignal().queries.map((opts) => {\n        const defaultedOptions = queryClient.defaultQueryOptions(\n          opts as QueryObserverOptions,\n        )\n        // Make sure the results are already in fetching state before subscribing or updating options\n        defaultedOptions._optimisticResults = isRestoring()\n          ? 'isRestoring'\n          : 'optimistic'\n\n        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n        return defaultedOptions as QueryObserverOptions\n      })\n    })\n\n    const observerSignal = (() => {\n      let instance: QueriesObserver<TCombinedResult> | null = null\n\n      return computed(() => {\n        return (instance ||= new QueriesObserver<TCombinedResult>(\n          queryClient,\n          defaultedQueries(),\n          optionsSignal() as QueriesObserverOptions<TCombinedResult>,\n        ))\n      })\n    })()\n\n    const optimisticResultSignal = computed(() =>\n      observerSignal().getOptimisticResult(\n        defaultedQueries(),\n        (optionsSignal() as QueriesObserverOptions<TCombinedResult>).combine,\n      ),\n    )\n\n    // Do not notify on updates because of changes in the options because\n    // these changes should already be reflected in the optimistic result.\n    effect(() => {\n      observerSignal().setQueries(\n        defaultedQueries(),\n        optionsSignal() as QueriesObserverOptions<TCombinedResult>,\n      )\n    })\n\n    const optimisticCombinedResultSignal = computed(() => {\n      const [_optimisticResult, getCombinedResult, trackResult] =\n        optimisticResultSignal()\n      return getCombinedResult(trackResult())\n    })\n\n    const resultFromSubscriberSignal = signal<TCombinedResult | null>(null)\n\n    effect(() => {\n      const observer = observerSignal()\n      const [_optimisticResult, getCombinedResult] = optimisticResultSignal()\n\n      untracked(() => {\n        const unsubscribe = isRestoring()\n          ? () => undefined\n          : ngZone.runOutsideAngular(() =>\n              observer.subscribe(\n                notifyManager.batchCalls((state) => {\n                  resultFromSubscriberSignal.set(getCombinedResult(state))\n                }),\n              ),\n            )\n\n        destroyRef.onDestroy(unsubscribe)\n      })\n    })\n\n    const resultSignal = computed(() => {\n      const subscriberResult = resultFromSubscriberSignal()\n      const optimisticResult = optimisticCombinedResultSignal()\n      return subscriberResult ?? optimisticResult\n    })\n\n    return computed(() => {\n      const result = resultSignal()\n      const { combine } = optionsSignal()\n\n      return combine\n        ? result\n        : (result as QueriesResults<T>).map((query) =>\n            signalProxy(signal(query)),\n          )\n    })\n  }) as unknown as Signal<TCombinedResult>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgXA,SAAgB,cAId,WACA,UACyB;CACzB,CAAC,YAAY,yBAAyB,aAAa;CACnD,OAAO,sBAAsB,YAAY,OAAO,QAAQ,SAAS;EAC/D,MAAM,aAAa,OAAO,UAAU;EACpC,MAAM,SAAS,OAAO,MAAM;EAC5B,MAAM,cAAc,OAAO,WAAW;EACtC,MAAM,cAAc,kBAAkB;;;;;;;EAQtC,MAAM,gBAAgB,eAAe;GACnC,OAAO,UAAU;EACnB,CAAC;EAED,MAAM,mBAAmB,eAAe;GACtC,OAAO,cAAc,CAAC,CAAC,QAAQ,KAAK,SAAS;IAC3C,MAAM,mBAAmB,YAAY,oBACnC,IACF;IAEA,iBAAiB,qBAAqB,YAAY,IAC9C,gBACA;IAGJ,OAAO;GACT,CAAC;EACH,CAAC;EAED,MAAM,wBAAwB;GAC5B,IAAI,WAAoD;GAExD,OAAO,eAAe;IACpB,OAAQ,aAAa,IAAI,gBACvB,aACA,iBAAiB,GACjB,cAAc,CAChB;GACF,CAAC;EACH,EAAA,CAAG;EAEH,MAAM,yBAAyB,eAC7B,eAAe,CAAC,CAAC,oBACf,iBAAiB,GAChB,cAAc,CAAC,CAA6C,OAC/D,CACF;EAIA,aAAa;GACX,eAAe,CAAC,CAAC,WACf,iBAAiB,GACjB,cAAc,CAChB;EACF,CAAC;EAED,MAAM,iCAAiC,eAAe;GACpD,MAAM,CAAC,mBAAmB,mBAAmB,eAC3C,uBAAuB;GACzB,OAAO,kBAAkB,YAAY,CAAC;EACxC,CAAC;EAED,MAAM,6BAA6B,OAA+B,IAAI;EAEtE,aAAa;GACX,MAAM,WAAW,eAAe;GAChC,MAAM,CAAC,mBAAmB,qBAAqB,uBAAuB;GAEtE,gBAAgB;IACd,MAAM,cAAc,YAAY,UACtB,KAAA,IACN,OAAO,wBACL,SAAS,UACP,cAAc,YAAY,UAAU;KAClC,2BAA2B,IAAI,kBAAkB,KAAK,CAAC;IACzD,CAAC,CACH,CACF;IAEJ,WAAW,UAAU,WAAW;GAClC,CAAC;EACH,CAAC;EAED,MAAM,eAAe,eAAe;GAClC,MAAM,mBAAmB,2BAA2B;GACpD,MAAM,mBAAmB,+BAA+B;GACxD,OAAO,oBAAoB;EAC7B,CAAC;EAED,OAAO,eAAe;GACpB,MAAM,SAAS,aAAa;GAC5B,MAAM,EAAE,YAAY,cAAc;GAElC,OAAO,UACH,SACC,OAA6B,KAAK,UACjC,YAAY,OAAO,KAAK,CAAC,CAC3B;EACN,CAAC;CACH,CAAC;AACH"}

package/dist/inject-query-client.d.mts

@@ -14,9 +14,8 @@ import { QueryClient } from "@tanstack/query-core";
  * const queryClient = injectQueryClient();
  * ```
  */
-declare function injectQueryClient(injectOptions?: InjectOptions & {
+export declare function injectQueryClient(injectOptions?: InjectOptions & {
   injector?: Injector;
 }): QueryClient;
 //#endregion
-export { injectQueryClient };
 //# sourceMappingURL=inject-query-client.d.mts.map

package/dist/inject-query-client.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"inject-query-client.d.mts","names":[],"sources":["../src/inject-query-client.ts"],"mappings":";;;;;;;;;;;;;;;;iBAiBgB,kBACd,gBAAe;EAAkB,WAAW;IAAe"}
+{"version":3,"file":"inject-query-client.d.mts","names":[],"sources":["../src/inject-query-client.ts"],"mappings":";;;;;;;;;;;;;;;;wBAiBgB,kBACd,gBAAe;EAAkB,WAAW;IAAe"}

package/dist/inject-query.d.mts

@@ -3,7 +3,7 @@ import { DefinedInitialDataOptions, UndefinedInitialDataOptions } from "./query-
 import { Injector } from "@angular/core";
 import { DefaultError, QueryKey } from "@tanstack/query-core";
 //#region src/inject-query.d.ts
-interface InjectQueryOptions {
+export interface InjectQueryOptions {
   /**
    * The `Injector` in which to create the query.
    *
@@ -51,7 +51,7 @@ interface InjectQueryOptions {
  * }
  * ```
  */
-declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(injectQueryFn: () => DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, options?: InjectQueryOptions): DefinedCreateQueryResult<TData, TError>;
+export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(injectQueryFn: () => DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, options?: InjectQueryOptions): DefinedCreateQueryResult<TData, TError>;
 /**
  * Injects a query: a declarative dependency on an asynchronous source of data that is tied to a unique key.
  *
@@ -126,7 +126,7 @@ declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TDat
  * }
  * ```
  */
-declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(injectQueryFn: () => UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, options?: InjectQueryOptions): CreateQueryResult<TData, TError>;
+export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(injectQueryFn: () => UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, options?: InjectQueryOptions): CreateQueryResult<TData, TError>;
 /**
  * This overload accepts the general {@link CreateQueryOptions} shape rather than the `initialData`-aware
  * overloads above, so whether `data` is defined can't be inferred from the call site — useful when wrapping
@@ -139,7 +139,6 @@ declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TDat
  * @param options - Additional configuration
  * @returns The query result.
  */
-declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(injectQueryFn: () => CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, options?: InjectQueryOptions): CreateQueryResult<TData, TError>;
+export declare function injectQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(injectQueryFn: () => CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, options?: InjectQueryOptions): CreateQueryResult<TData, TError>;
 //#endregion
-export { InjectQueryOptions, injectQuery };
 //# sourceMappingURL=inject-query.d.mts.map

package/dist/inject-query.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"inject-query.d.mts","names":[],"sources":["../src/inject-query.ts"],"mappings":";;;;;UAmBiB;;;;;;EAMf,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2CG,YACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,qBAAqB,0BACnB,cACA,QACA,OACA,YAEF,UAAU,qBACT,yBAAyB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4EnB,YACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,qBAAqB,4BACnB,cACA,QACA,OACA,YAEF,UAAU,qBACT,kBAAkB,OAAO;;;;;;;;;;;;;iBAcZ,YACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,qBAAqB,mBACnB,cACA,QACA,OACA,YAEF,UAAU,qBACT,kBAAkB,OAAO"}
+{"version":3,"file":"inject-query.d.mts","names":[],"sources":["../src/inject-query.ts"],"mappings":";;;;;iBAmBiB;;;;;;EAMf,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2CG,YACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,qBAAqB,0BACnB,cACA,QACA,OACA,YAEF,UAAU,qBACT,yBAAyB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA4EnB,YACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,qBAAqB,4BACnB,cACA,QACA,OACA,YAEF,UAAU,qBACT,kBAAkB,OAAO;;;;;;;;;;;;;wBAcZ,YACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,qBAAqB,mBACnB,cACA,QACA,OACA,YAEF,UAAU,qBACT,kBAAkB,OAAO"}

package/dist/mutation-options.d.mts

@@ -37,7 +37,7 @@ import { DefaultError, WithRequired } from "@tanstack/query-core";
  * }
  * ```
  */
-declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
+export declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
 /**
  * You can generally pass everything to `mutationOptions` that you can also pass to `injectMutation`. No
  * `mutationKey` is required on this overload — use this when you don't need to target the mutation via a
@@ -82,7 +82,6 @@ declare function mutationOptions<TData = unknown, TError = DefaultError, TVariab
  * }
  * ```
  */
-declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
+export declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
 //#endregion
-export { mutationOptions };
 //# sourceMappingURL=mutation-options.d.mts.map

package/dist/mutation-options.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"mutation-options.d.mts","names":[],"sources":["../src/mutation-options.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCgB,gBACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,aACP,sBAAsB,OAAO,QAAQ,YAAY,mCAGlD,aACD,sBAAsB,OAAO,QAAQ,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+CnC,gBACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,KACP,sBAAsB,OAAO,QAAQ,YAAY,mCAGlD,KACD,sBAAsB,OAAO,QAAQ,YAAY"}
+{"version":3,"file":"mutation-options.d.mts","names":[],"sources":["../src/mutation-options.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAuCgB,gBACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,aACP,sBAAsB,OAAO,QAAQ,YAAY,mCAGlD,aACD,sBAAsB,OAAO,QAAQ,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+CnC,gBACd,iBACA,SAAS,cACT,mBACA,2BAEA,SAAS,KACP,sBAAsB,OAAO,QAAQ,YAAY,mCAGlD,KACD,sBAAsB,OAAO,QAAQ,YAAY"}

package/dist/pending-tasks-compat.d.mts

@@ -3,8 +3,7 @@ import { InjectionToken } from "@angular/core";
 type PendingTasksCompat = {
   add: () => PendingTaskRef;
 };
-type PendingTaskRef = () => void;
-declare const PENDING_TASKS: InjectionToken<PendingTasksCompat>;
+export type PendingTaskRef = () => void;
+export declare const PENDING_TASKS: InjectionToken<PendingTasksCompat>;
 //#endregion
-export { PENDING_TASKS, PendingTaskRef };
 //# sourceMappingURL=pending-tasks-compat.d.mts.map

package/dist/pending-tasks-compat.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"pending-tasks-compat.d.mts","names":[],"sources":["../src/pending-tasks-compat.ts"],"mappings":";;KAIK;EAAuB,WAAW;;KAE3B;cAEC,eAAa,eAAA"}
+{"version":3,"file":"pending-tasks-compat.d.mts","names":[],"sources":["../src/pending-tasks-compat.ts"],"mappings":";;KAIK;EAAuB,WAAW;;YAE3B;qBAEC,eAAa,eAAA"}

package/dist/providers.d.mts

@@ -18,7 +18,7 @@ import { QueryClient } from "@tanstack/query-core";
  * })
  * ```
  */
-declare function provideQueryClient(queryClient: QueryClient | InjectionToken<QueryClient>): Provider;
+export declare function provideQueryClient(queryClient: QueryClient | InjectionToken<QueryClient>): Provider;
 /**
  * Sets up providers necessary to enable TanStack Query functionality for Angular applications. Allows
  * configuring a `QueryClient` and optional features such as developer tools.
@@ -81,7 +81,7 @@ declare function provideQueryClient(queryClient: QueryClient | InjectionToken<Qu
  * providers: [provideTanStackQuery(MY_QUERY_CLIENT)]
  * ```
  */
-declare function provideTanStackQuery(queryClient: QueryClient | InjectionToken<QueryClient>, ...features: Array<QueryFeatures>): Array<Provider>;
+export declare function provideTanStackQuery(queryClient: QueryClient | InjectionToken<QueryClient>, ...features: Array<QueryFeatures>): Array<Provider>;
 /**
  * Sets up providers necessary to enable TanStack Query functionality for Angular applications.
  *
@@ -91,13 +91,13 @@ declare function provideTanStackQuery(queryClient: QueryClient | InjectionToken<
  * @returns A set of providers to set up TanStack Query.
  * @deprecated Use `provideTanStackQuery` instead.
  */
-declare function provideAngularQuery(queryClient: QueryClient): Array<Provider>;
+export declare function provideAngularQuery(queryClient: QueryClient): Array<Provider>;
 declare const queryFeatures: readonly ["Devtools", "PersistQueryClient"];
 type QueryFeatureKind = (typeof queryFeatures)[number];
 /**
  * Helper type to represent a Query feature.
  */
-interface QueryFeature<TFeatureKind extends QueryFeatureKind> {
+export interface QueryFeature<TFeatureKind extends QueryFeatureKind> {
   ɵkind: TFeatureKind;
   ɵproviders: Array<Provider>;
 }
@@ -107,18 +107,18 @@ interface QueryFeature<TFeatureKind extends QueryFeatureKind> {
  * @param providers - The Angular providers this feature contributes to `provideTanStackQuery`.
  * @returns A Query feature.
  */
-declare function queryFeature<TFeatureKind extends QueryFeatureKind>(kind: TFeatureKind, providers: Array<Provider>): QueryFeature<TFeatureKind>;
+export declare function queryFeature<TFeatureKind extends QueryFeatureKind>(kind: TFeatureKind, providers: Array<Provider>): QueryFeature<TFeatureKind>;
 /**
  * A type alias that represents a feature which enables developer tools.
  * The type is used to describe the return value of the `withDevtools` function.
  * @see {@link withDevtools}
  */
-type DevtoolsFeature = QueryFeature<'Devtools'>;
+export type DevtoolsFeature = QueryFeature<'Devtools'>;
 /**
  * A type alias that represents a feature which enables persistence.
  * The type is used to describe the return value of the `withPersistQueryClient` function.
  */
-type PersistQueryClientFeature = QueryFeature<'PersistQueryClient'>;
+export type PersistQueryClientFeature = QueryFeature<'PersistQueryClient'>;
 /**
  * A type alias that represents all Query features available for use with `provideTanStackQuery`.
  * Features can be enabled by adding special functions to the `provideTanStackQuery` call.
@@ -126,7 +126,6 @@ type PersistQueryClientFeature = QueryFeature<'PersistQueryClient'>;
  * documentation on how to use those functions.
  * @see {@link provideTanStackQuery}
  */
-type QueryFeatures = DevtoolsFeature | PersistQueryClientFeature;
+export type QueryFeatures = DevtoolsFeature | PersistQueryClientFeature;
 //#endregion
-export { DevtoolsFeature, PersistQueryClientFeature, QueryFeature, QueryFeatures, provideAngularQuery, provideQueryClient, provideTanStackQuery, queryFeature };
 //# sourceMappingURL=providers.d.mts.map

package/dist/providers.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"providers.d.mts","names":[],"sources":["../src/providers.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBAqBgB,mBACd,aAAa,cAAc,eAAe,eACzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8Ea,qBACd,aAAa,cAAc,eAAe,iBACvC,UAAU,MAAM,iBAClB,MAAM;;;;;;;;;;iBAgBO,oBAAoB,aAAa,cAAc,MAAM;cAI/D;KAED,2BAA2B;;;;UAKf,aAAa,qBAAqB;EACjD,OAAO;EACP,YAAY,MAAM;;;;;;;;iBASJ,aAAa,qBAAqB,kBAChD,MAAM,cACN,WAAW,MAAM,YAChB,aAAa;;;;;;KASJ,kBAAkB;;;;;KAMlB,4BAA4B;;;;;;;;KAS5B,gBAAgB,kBAAkB"}
+{"version":3,"file":"providers.d.mts","names":[],"sources":["../src/providers.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;wBAqBgB,mBACd,aAAa,cAAc,eAAe,eACzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8Ea,qBACd,aAAa,cAAc,eAAe,iBACvC,UAAU,MAAM,iBAClB,MAAM;;;;;;;;;;wBAgBO,oBAAoB,aAAa,cAAc,MAAM;cAI/D;KAED,2BAA2B;;;;iBAKf,aAAa,qBAAqB;EACjD,OAAO;EACP,YAAY,MAAM;;;;;;;;wBASJ,aAAa,qBAAqB,kBAChD,MAAM,cACN,WAAW,MAAM,YAChB,aAAa;;;;;;YASJ,kBAAkB;;;;;YAMlB,4BAA4B;;;;;;;;YAS5B,gBAAgB,kBAAkB"}

package/dist/query-options.d.mts

@@ -10,7 +10,7 @@ import { DefaultError, InitialDataFunction, NonUndefinedGuard, OmitKeyof, QueryF
  * @template TData - The type `data` ends up as after `select` runs.
  * @template TQueryKey - The type of your `queryKey`.
  */
-type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+export type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
   /**
    * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
    * created or cached yet). If set to a function, the function will be called **once** during the shared/root
@@ -29,7 +29,7 @@ type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError,
  * @template TData - The type `data` ends up as after `select` runs.
  * @template TQueryKey - The type of your `queryKey`.
  */
-type UnusedSkipTokenOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
+export type UnusedSkipTokenOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
   /**
    * `skipToken` is not allowed as a value here — this overload is selected when no `initialData` is set. If
    * you don't intend to run the query yet, set `enabled: false` — omitting `queryFn` alone still triggers a
@@ -47,7 +47,7 @@ type UnusedSkipTokenOptions<TQueryFnData = unknown, TError = DefaultError, TData
  * @template TData - The type `data` ends up as after `select` runs.
  * @template TQueryKey - The type of your `queryKey`.
  */
-type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
+export type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryFn'> & {
   /**
    * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been
    * created or cached yet). If set to a function, the function will be called **once** during the shared/root
@@ -107,7 +107,7 @@ type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TD
  * }
  * ```
  */
-declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
+export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
 /**
  * You can generally pass everything to `queryOptions` that you can also pass to `injectQuery`. These options
  * can be shared across functions and imperative APIs such as `queryClient.fetchQuery`. `options.queryKey` is
@@ -147,7 +147,7 @@ declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TDa
  * }
  * ```
  */
-declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
+export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey>): UnusedSkipTokenOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
 /**
  * You can generally pass everything to `queryOptions` that you can also pass to `injectQuery`. These options
  * can be shared across functions and imperative APIs such as `queryClient.fetchQuery`. `options.queryKey` is
@@ -219,7 +219,6 @@ declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TDa
  * }
  * ```
  */
-declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
+export declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>;
 //#endregion
-export { DefinedInitialDataOptions, UndefinedInitialDataOptions, UnusedSkipTokenOptions, queryOptions };
 //# sourceMappingURL=query-options.d.mts.map

package/dist/query-options.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"query-options.d.mts","names":[],"sources":["../src/query-options.ts"],"mappings":";;;;;;;;;;;;KAqBY,4BACV,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,mBAAmB,cAAc,QAAQ,OAAO;;;;;;;;EAQlD,0BAEI,oBAAoB,kBAAkB,iBACtC,kBAAkB;;;;;;;;;;;KAYZ,uBACV,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,UACF,mBAAmB,cAAc,QAAQ,OAAO;;;;;;;EAShD,UAAU,QACR,mBAAmB,cAAc,QAAQ,OAAO,uBAChD;;;;;;;;;;;KAaQ,0BACV,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,KACF,mBAAmB,cAAc,QAAQ,OAAO;;;;;;;;EAUhD,aACE,kBAAkB,uBAAuB,kBAAkB;;;;;;EAM7D,UAAU,cAAc,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+CxB,aACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,0BAA0B,cAAc,QAAQ,OAAO,aAC/D,0BAA0B,cAAc,QAAQ,OAAO,aACxD,oBAAoB,WAAW,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyC/B,aACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,uBAAuB,cAAc,QAAQ,OAAO,aAC5D,uBAAuB,cAAc,QAAQ,OAAO,aACrD,oBAAoB,WAAW,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyE/B,aACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,4BAA4B,cAAc,QAAQ,OAAO,aACjE,4BAA4B,cAAc,QAAQ,OAAO,aAC1D,oBAAoB,WAAW,cAAc"}
+{"version":3,"file":"query-options.d.mts","names":[],"sources":["../src/query-options.ts"],"mappings":";;;;;;;;;;;;YAqBY,4BACV,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,mBAAmB,cAAc,QAAQ,OAAO;;;;;;;;EAQlD,0BAEI,oBAAoB,kBAAkB,iBACtC,kBAAkB;;;;;;;;;;;YAYZ,uBACV,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,UACF,mBAAmB,cAAc,QAAQ,OAAO;;;;;;;EAShD,UAAU,QACR,mBAAmB,cAAc,QAAQ,OAAO,uBAChD;;;;;;;;;;;YAaQ,0BACV,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,YAC3B,KACF,mBAAmB,cAAc,QAAQ,OAAO;;;;;;;;EAUhD,aACE,kBAAkB,uBAAuB,kBAAkB;;;;;;EAM7D,UAAU,cAAc,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+CxB,aACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,0BAA0B,cAAc,QAAQ,OAAO,aAC/D,0BAA0B,cAAc,QAAQ,OAAO,aACxD,oBAAoB,WAAW,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyC/B,aACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,uBAAuB,cAAc,QAAQ,OAAO,aAC5D,uBAAuB,cAAc,QAAQ,OAAO,aACrD,oBAAoB,WAAW,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyE/B,aACd,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAE7B,SAAS,4BAA4B,cAAc,QAAQ,OAAO,aACjE,4BAA4B,cAAc,QAAQ,OAAO,aAC1D,oBAAoB,WAAW,cAAc"}

package/dist/signal-proxy.d.mts

@@ -1,13 +1,12 @@
 import { Signal } from "@angular/core";
 //#region src/signal-proxy.d.ts
-type MapToSignals<T> = { [K in keyof T]: T[K] extends Function ? T[K] : Signal<T[K]>; };
+export type MapToSignals<T> = { [K in keyof T]: T[K] extends Function ? T[K] : Signal<T[K]>; };
 /**
  * Exposes fields of an object passed via an Angular `Signal` as `Computed` signals.
  * Functions on the object are passed through as-is.
  * @param inputSignal - `Signal` that must return an object.
  * @returns A proxy object with the same fields as the input object, but with each field wrapped in a `Computed` signal.
  */
-declare function signalProxy<TInput extends Record<string | symbol, any>>(inputSignal: Signal<TInput>): MapToSignals<TInput>;
+export declare function signalProxy<TInput extends Record<string | symbol, any>>(inputSignal: Signal<TInput>): MapToSignals<TInput>;
 //#endregion
-export { MapToSignals, signalProxy };
 //# sourceMappingURL=signal-proxy.d.mts.map

package/dist/signal-proxy.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"signal-proxy.d.mts","names":[],"sources":["../src/signal-proxy.ts"],"mappings":";;KAGY,aAAa,QACtB,WAAW,IAAI,EAAE,WAAW,WAAW,EAAE,KAAK,OAAO,EAAE;;;;;;;iBAS1C,YAAY,eAAe,8BACzC,aAAa,OAAO,UAAO,aAAA"}
+{"version":3,"file":"signal-proxy.d.mts","names":[],"sources":["../src/signal-proxy.ts"],"mappings":";;YAGY,aAAa,QACtB,WAAW,IAAI,EAAE,WAAW,WAAW,EAAE,KAAK,OAAO,EAAE;;;;;;;wBAS1C,YAAY,eAAe,8BACzC,aAAa,OAAO,UAAO,aAAA"}

package/dist/types.d.mts

@@ -15,7 +15,7 @@ import { DefaultError, DefinedInfiniteQueryObserverResult, DefinedQueryObserverR
  * `placeholderData`. Defaults to, and is usually the same as, `TQueryFnData`.
  * @template TQueryKey - The type of your `queryKey`.
  */
-interface CreateBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {}
+export interface CreateBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {}
 /**
  * The options accepted by `injectQuery`. Same as {@link CreateBaseQueryOptions}, minus `suspense` — which
  * `angular-query-experimental` doesn't support, unlike `react-query`.
@@ -26,7 +26,7 @@ interface CreateBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError,
  * `select` is used.
  * @template TQueryKey - The type of your `queryKey`.
  */
-interface CreateQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'suspense'> {}
+export interface CreateQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'suspense'> {}
 type CreateStatusBasedQueryResult<TStatus extends QueryObserverResult['status'], TData = unknown, TError = DefaultError> = Extract<QueryObserverResult<TData, TError>, {
   status: TStatus;
 }>;
@@ -39,7 +39,7 @@ type CreateStatusBasedQueryResult<TStatus extends QueryObserverResult['status'],
  * @template TData - The type `data` ends up as after `select` runs.
  * @template TError - The type of errors your `queryFn` may throw.
  */
-interface BaseQueryNarrowing<TData = unknown, TError = DefaultError> {
+export interface BaseQueryNarrowing<TData = unknown, TError = DefaultError> {
   isSuccess: (this: CreateBaseQueryResult<TData, TError>) => this is CreateBaseQueryResult<TData, TError, CreateStatusBasedQueryResult<'success', TData, TError>>;
   isError: (this: CreateBaseQueryResult<TData, TError>) => this is CreateBaseQueryResult<TData, TError, CreateStatusBasedQueryResult<'error', TData, TError>>;
   isPending: (this: CreateBaseQueryResult<TData, TError>) => this is CreateBaseQueryResult<TData, TError, CreateStatusBasedQueryResult<'pending', TData, TError>>;
@@ -58,7 +58,7 @@ interface BaseQueryNarrowing<TData = unknown, TError = DefaultError> {
  * @template TQueryKey - The type of your `queryKey`.
  * @template TPageParam - The type of the parameter passed to `queryFn` to fetch a given page.
  */
-interface CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'suspense'> {}
+export interface CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'suspense'> {}
 /**
  * The result of `injectQuery` when `initialData` isn't set — `data` may be `undefined` while the query is
  * `pending`. Same shape as {@link QueryObserverResult} from `@tanstack/query-core`, but value fields (like
@@ -70,14 +70,14 @@ interface CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultErr
  * @template TData - The type `data` ends up as after `select` runs.
  * @template TError - The type of errors your `queryFn` may throw.
  */
-type CreateBaseQueryResult<TData = unknown, TError = DefaultError, TState = QueryObserverResult<TData, TError>> = BaseQueryNarrowing<TData, TError> & MapToSignals<OmitKeyof<TState, keyof BaseQueryNarrowing, 'safely'>>;
+export type CreateBaseQueryResult<TData = unknown, TError = DefaultError, TState = QueryObserverResult<TData, TError>> = BaseQueryNarrowing<TData, TError> & MapToSignals<OmitKeyof<TState, keyof BaseQueryNarrowing, 'safely'>>;
 /**
  * The result of `injectQuery`. Same as {@link CreateBaseQueryResult}.
  *
  * @template TData - The type `data` ends up as after `select` runs.
  * @template TError - The type of errors your `queryFn` may throw.
  */
-type CreateQueryResult<TData = unknown, TError = DefaultError> = CreateBaseQueryResult<TData, TError>;
+export type CreateQueryResult<TData = unknown, TError = DefaultError> = CreateBaseQueryResult<TData, TError>;
 /**
  * The result of `injectQuery` when `initialData` is set — `data` is never `undefined`. Same shape as
  * {@link DefinedQueryObserverResult} from `@tanstack/query-core`, but value fields are exposed as a
@@ -86,7 +86,7 @@ type CreateQueryResult<TData = unknown, TError = DefaultError> = CreateBaseQuery
  * @template TData - The type `data` ends up as after `select` runs.
  * @template TError - The type of errors your `queryFn` may throw.
  */
-type DefinedCreateQueryResult<TData = unknown, TError = DefaultError, TState = DefinedQueryObserverResult<TData, TError>> = BaseQueryNarrowing<TData, TError> & MapToSignals<OmitKeyof<TState, keyof BaseQueryNarrowing, 'safely'>>;
+export type DefinedCreateQueryResult<TData = unknown, TError = DefaultError, TState = DefinedQueryObserverResult<TData, TError>> = BaseQueryNarrowing<TData, TError> & MapToSignals<OmitKeyof<TState, keyof BaseQueryNarrowing, 'safely'>>;
 /**
  * The result of `injectInfiniteQuery` when `initialData` isn't set — `data` may be `undefined` while the
  * query is `pending`. Same shape as {@link InfiniteQueryObserverResult} from `@tanstack/query-core`, but
@@ -96,7 +96,7 @@ type DefinedCreateQueryResult<TData = unknown, TError = DefaultError, TState = D
  * @template TData - The type `data` ends up as after `select` runs.
  * @template TError - The type of errors your `queryFn` may throw.
  */
-type CreateInfiniteQueryResult<TData = unknown, TError = DefaultError> = BaseQueryNarrowing<TData, TError> & MapToSignals<InfiniteQueryObserverResult<TData, TError>>;
+export type CreateInfiniteQueryResult<TData = unknown, TError = DefaultError> = BaseQueryNarrowing<TData, TError> & MapToSignals<InfiniteQueryObserverResult<TData, TError>>;
 /**
  * The result of `injectInfiniteQuery` when `initialData` is set — `data` is never `undefined`. Same shape as
  * {@link DefinedInfiniteQueryObserverResult} from `@tanstack/query-core`, but value fields are exposed as a
@@ -105,7 +105,7 @@ type CreateInfiniteQueryResult<TData = unknown, TError = DefaultError> = BaseQue
  * @template TData - The type `data` ends up as after `select` runs.
  * @template TError - The type of errors your `queryFn` may throw.
  */
-type DefinedCreateInfiniteQueryResult<TData = unknown, TError = DefaultError, TDefinedInfiniteQueryObserver = DefinedInfiniteQueryObserverResult<TData, TError>> = MapToSignals<TDefinedInfiniteQueryObserver>;
+export type DefinedCreateInfiniteQueryResult<TData = unknown, TError = DefaultError, TDefinedInfiniteQueryObserver = DefinedInfiniteQueryObserverResult<TData, TError>> = MapToSignals<TDefinedInfiniteQueryObserver>;
 /**
  * The options accepted by `injectMutation`. Same as {@link MutationObserverOptions} from
  * `@tanstack/query-core`, minus the internal `_defaulted` flag.
@@ -116,7 +116,7 @@ type DefinedCreateInfiniteQueryResult<TData = unknown, TError = DefaultError, TD
  * @template TOnMutateResult - The type returned by `onMutate`, passed to `onSuccess`/`onError`/`onSettled` as
  * their `onMutateResult` parameter — useful for optimistic-update rollback data.
  */
-interface CreateMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {}
+export interface CreateMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {}
 /**
  * The type of `mutate`, as returned by `injectMutation`. Forwards the variables (and an optional per-call
  * `onSuccess`/`onError`/`onSettled`) to the underlying `mutate` call. Fire-and-forget — errors are surfaced
@@ -128,7 +128,7 @@ interface CreateMutationOptions<TData = unknown, TError = DefaultError, TVariabl
  * @template TOnMutateResult - The type returned by `onMutate`, passed to `onSuccess`/`onError`/`onSettled` as
  * their `onMutateResult` parameter — useful for optimistic-update rollback data.
  */
-type CreateMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
+export type CreateMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
 /**
  * The type of `mutateAsync`, as returned by `injectMutation`. Similar to {@link CreateMutateFunction}, but
  * returns a promise which can be awaited.
@@ -139,7 +139,7 @@ type CreateMutateFunction<TData = unknown, TError = DefaultError, TVariables = v
  * @template TOnMutateResult - The type returned by `onMutate`, passed to `onSuccess`/`onError`/`onSettled` as
  * their `onMutateResult` parameter — useful for optimistic-update rollback data.
  */
-type CreateMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutateFunction<TData, TError, TVariables, TOnMutateResult>;
+export type CreateMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutateFunction<TData, TError, TVariables, TOnMutateResult>;
 /**
  * The pre-`Signal` shape {@link CreateMutationResult} is built from — not what `injectMutation` actually
  * returns. Same as {@link MutationObserverResult} from `@tanstack/query-core`, with `mutate` narrowed to the
@@ -151,7 +151,7 @@ type CreateMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariable
  * @template TOnMutateResult - The type returned by `onMutate`, passed to `onSuccess`/`onError`/`onSettled` as
  * their `onMutateResult` parameter — useful for optimistic-update rollback data.
  */
-type CreateBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, {
+export type CreateBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, {
   mutate: CreateMutateFunction<TData, TError, TVariables, TOnMutateResult>;
 }> & {
   /**
@@ -174,7 +174,7 @@ type SignalFunction<T extends () => any> = T & Signal<ReturnType<T>>;
  * @template TOnMutateResult - The type returned by `onMutate`, passed to `onSuccess`/`onError`/`onSettled` as
  * their `onMutateResult` parameter — useful for optimistic-update rollback data.
  */
-interface BaseMutationNarrowing<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> {
+export interface BaseMutationNarrowing<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> {
   isSuccess: SignalFunction<(this: CreateMutationResult<TData, TError, TVariables, TOnMutateResult>) => this is CreateMutationResult<TData, TError, TVariables, TOnMutateResult, CreateStatusBasedMutationResult<'success', TData, TError, TVariables, TOnMutateResult>>>;
   isError: SignalFunction<(this: CreateMutationResult<TData, TError, TVariables, TOnMutateResult>) => this is CreateMutationResult<TData, TError, TVariables, TOnMutateResult, CreateStatusBasedMutationResult<'error', TData, TError, TVariables, TOnMutateResult>>>;
   isPending: SignalFunction<(this: CreateMutationResult<TData, TError, TVariables, TOnMutateResult>) => this is CreateMutationResult<TData, TError, TVariables, TOnMutateResult, CreateStatusBasedMutationResult<'pending', TData, TError, TVariables, TOnMutateResult>>>;
@@ -192,7 +192,6 @@ interface BaseMutationNarrowing<TData = unknown, TError = DefaultError, TVariabl
  * @template TOnMutateResult - The type returned by `onMutate`, passed to `onSuccess`/`onError`/`onSettled` as
  * their `onMutateResult` parameter — useful for optimistic-update rollback data.
  */
-type CreateMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown, TState = CreateStatusBasedMutationResult<CreateBaseMutationResult['status'], TData, TError, TVariables, TOnMutateResult>> = BaseMutationNarrowing<TData, TError, TVariables, TOnMutateResult> & MapToSignals<OmitKeyof<TState, keyof BaseMutationNarrowing, 'safely'>>;
+export type CreateMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown, TState = CreateStatusBasedMutationResult<CreateBaseMutationResult['status'], TData, TError, TVariables, TOnMutateResult>> = BaseMutationNarrowing<TData, TError, TVariables, TOnMutateResult> & MapToSignals<OmitKeyof<TState, keyof BaseMutationNarrowing, 'safely'>>;
 //#endregion
-export { BaseMutationNarrowing, BaseQueryNarrowing, CreateBaseMutationResult, CreateBaseQueryOptions, CreateBaseQueryResult, CreateInfiniteQueryOptions, CreateInfiniteQueryResult, CreateMutateAsyncFunction, CreateMutateFunction, CreateMutationOptions, CreateMutationResult, CreateQueryOptions, CreateQueryResult, DefinedCreateInfiniteQueryResult, DefinedCreateQueryResult };
 //# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;;;;;;;;;;UAiCiB,uBACf,wBACA,SAAS,cACT,QAAQ,cACR,aAAa,cACb,kBAAkB,WAAW,kBACrB,qBACR,cACA,QACA,OACA,YACA;;;;;;;;;;;UAae,mBACf,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,kBACrB,UACR,uBAAuB,cAAc,QAAQ,OAAO,cAAc;KAI/D,6BACH,gBAAgB,+BAChB,iBACA,SAAS,gBACP,QAAQ,oBAAoB,OAAO;EAAW,QAAQ;;;;;;;;;;;UAWzC,mBAAmB,iBAAiB,SAAS;EAC5D,YACE,MAAM,sBAAsB,OAAO,oBACxB,sBACX,OACA,QACA,wCAAwC,OAAO;EAEjD,UACE,MAAM,sBAAsB,OAAO,oBACxB,sBACX,OACA,QACA,sCAAsC,OAAO;EAE/C,YACE,MAAM,sBAAsB,OAAO,oBACxB,sBACX,OACA,QACA,wCAAwC,OAAO;;;;;;;;;;;;;;;;UAkBlC,2BACf,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAC7B,8BACQ,UACR,6BACE,cACA,QACA,OACA,WACA;;;;;;;;;;;;KAgBQ,sBACV,iBACA,SAAS,cACT,SAAS,oBAAoB,OAAO,WAClC,mBAAmB,OAAO,UAC5B,aAAa,UAAU,cAAc;;;;;;;KAQ3B,kBACV,iBACA,SAAS,gBACP,sBAAsB,OAAO;;;;;;;;;KAUrB,yBACV,iBACA,SAAS,cACT,SAAS,2BAA2B,OAAO,WACzC,mBAAmB,OAAO,UAC5B,aAAa,UAAU,cAAc;;;;;;;;;;KAW3B,0BACV,iBACA,SAAS,gBACP,mBAAmB,OAAO,UAC5B,aAAa,4BAA4B,OAAO;;;;;;;;;KAUtC,iCACV,iBACA,SAAS,cACT,gCAAgC,mCAC9B,OACA,WAEA,aAAa;;;;;;;;;;;UAYA,sBACf,iBACA,SAAS,cACT,mBACA,mCACQ,UACR,wBAAwB,OAAO,QAAQ,YAAY;;;;;;;;;;;;KAezC,qBACV,iBACA,SAAS,cACT,mBACA,iCAEG,MAAM,WACP,eAAe,OAAO,QAAQ,YAAY;;;;;;;;;;;KAclC,0BACV,iBACA,SAAS,cACT,mBACA,6BACE,eAAe,OAAO,QAAQ,YAAY;;;;;;;;;;;;KAalC,yBACV,iBACA,SAAS,cACT,sBACA,6BACE,SACF,uBAAuB,OAAO,QAAQ,YAAY;EAChD,QAAQ,qBAAqB,OAAO,QAAQ,YAAY;;;;;EAK1D,aAAa,0BACX,OACA,QACA,YACA;;KAIC,gCACH,gBAAgB,oCAChB,iBACA,SAAS,cACT,sBACA,6BACE,QACF,yBAAyB,OAAO,QAAQ,YAAY;EAClD,QAAQ;;KAGP,eAAe,uBAAuB,IAAI,OAAO,WAAW;;;;;;;;;;;;UAahD,sBACf,iBACA,SAAS,cACT,sBACA;EAEA,WAAW,gBAEP,MAAM,qBAAqB,OAAO,QAAQ,YAAY,6BAC3C,qBACX,OACA,QACA,YACA,iBACA,2CAEE,OACA,QACA,YACA;EAIN,SAAS,gBAEL,MAAM,qBAAqB,OAAO,QAAQ,YAAY,6BAC3C,qBACX,OACA,QACA,YACA,iBACA,yCAEE,OACA,QACA,YACA;EAIN,WAAW,gBAEP,MAAM,qBAAqB,OAAO,QAAQ,YAAY,6BAC3C,qBACX,OACA,QACA,YACA,iBACA,2CAEE,OACA,QACA,YACA;EAIN,QAAQ,gBAEJ,MAAM,qBAAqB,OAAO,QAAQ,YAAY,6BAC3C,qBACX,OACA,QACA,YACA,iBACA,wCAEE,OACA,QACA,YACA;;;;;;;;;;;;;;KAkBI,qBACV,iBACA,SAAS,cACT,sBACA,2BACA,SAAS,gCACP,oCACA,OACA,QACA,YACA,oBAEA,sBAAsB,OAAO,QAAQ,YAAY,mBACnD,aAAa,UAAU,cAAc"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;;;;;;;;;;iBAiCiB,uBACf,wBACA,SAAS,cACT,QAAQ,cACR,aAAa,cACb,kBAAkB,WAAW,kBACrB,qBACR,cACA,QACA,OACA,YACA;;;;;;;;;;;iBAae,mBACf,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,kBACrB,UACR,uBAAuB,cAAc,QAAQ,OAAO,cAAc;KAI/D,6BACH,gBAAgB,+BAChB,iBACA,SAAS,gBACP,QAAQ,oBAAoB,OAAO;EAAW,QAAQ;;;;;;;;;;;iBAWzC,mBAAmB,iBAAiB,SAAS;EAC5D,YACE,MAAM,sBAAsB,OAAO,oBACxB,sBACX,OACA,QACA,wCAAwC,OAAO;EAEjD,UACE,MAAM,sBAAsB,OAAO,oBACxB,sBACX,OACA,QACA,sCAAsC,OAAO;EAE/C,YACE,MAAM,sBAAsB,OAAO,oBACxB,sBACX,OACA,QACA,wCAAwC,OAAO;;;;;;;;;;;;;;;;iBAkBlC,2BACf,wBACA,SAAS,cACT,QAAQ,cACR,kBAAkB,WAAW,UAC7B,8BACQ,UACR,6BACE,cACA,QACA,OACA,WACA;;;;;;;;;;;;YAgBQ,sBACV,iBACA,SAAS,cACT,SAAS,oBAAoB,OAAO,WAClC,mBAAmB,OAAO,UAC5B,aAAa,UAAU,cAAc;;;;;;;YAQ3B,kBACV,iBACA,SAAS,gBACP,sBAAsB,OAAO;;;;;;;;;YAUrB,yBACV,iBACA,SAAS,cACT,SAAS,2BAA2B,OAAO,WACzC,mBAAmB,OAAO,UAC5B,aAAa,UAAU,cAAc;;;;;;;;;;YAW3B,0BACV,iBACA,SAAS,gBACP,mBAAmB,OAAO,UAC5B,aAAa,4BAA4B,OAAO;;;;;;;;;YAUtC,iCACV,iBACA,SAAS,cACT,gCAAgC,mCAC9B,OACA,WAEA,aAAa;;;;;;;;;;;iBAYA,sBACf,iBACA,SAAS,cACT,mBACA,mCACQ,UACR,wBAAwB,OAAO,QAAQ,YAAY;;;;;;;;;;;;YAezC,qBACV,iBACA,SAAS,cACT,mBACA,iCAEG,MAAM,WACP,eAAe,OAAO,QAAQ,YAAY;;;;;;;;;;;YAclC,0BACV,iBACA,SAAS,cACT,mBACA,6BACE,eAAe,OAAO,QAAQ,YAAY;;;;;;;;;;;;YAalC,yBACV,iBACA,SAAS,cACT,sBACA,6BACE,SACF,uBAAuB,OAAO,QAAQ,YAAY;EAChD,QAAQ,qBAAqB,OAAO,QAAQ,YAAY;;;;;EAK1D,aAAa,0BACX,OACA,QACA,YACA;;KAIC,gCACH,gBAAgB,oCAChB,iBACA,SAAS,cACT,sBACA,6BACE,QACF,yBAAyB,OAAO,QAAQ,YAAY;EAClD,QAAQ;;KAGP,eAAe,uBAAuB,IAAI,OAAO,WAAW;;;;;;;;;;;;iBAahD,sBACf,iBACA,SAAS,cACT,sBACA;EAEA,WAAW,gBAEP,MAAM,qBAAqB,OAAO,QAAQ,YAAY,6BAC3C,qBACX,OACA,QACA,YACA,iBACA,2CAEE,OACA,QACA,YACA;EAIN,SAAS,gBAEL,MAAM,qBAAqB,OAAO,QAAQ,YAAY,6BAC3C,qBACX,OACA,QACA,YACA,iBACA,yCAEE,OACA,QACA,YACA;EAIN,WAAW,gBAEP,MAAM,qBAAqB,OAAO,QAAQ,YAAY,6BAC3C,qBACX,OACA,QACA,YACA,iBACA,2CAEE,OACA,QACA,YACA;EAIN,QAAQ,gBAEJ,MAAM,qBAAqB,OAAO,QAAQ,YAAY,6BAC3C,qBACX,OACA,QACA,YACA,iBACA,wCAEE,OACA,QACA,YACA;;;;;;;;;;;;;;YAkBI,qBACV,iBACA,SAAS,cACT,sBACA,2BACA,SAAS,gCACP,oCACA,OACA,QACA,YACA,oBAEA,sBAAsB,OAAO,QAAQ,YAAY,mBACnD,aAAa,UAAU,cAAc"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/angular-query-experimental",
-  "version": "5.103.3",
+  "version": "5.104.0",
   "description": "Signals for managing, caching and syncing asynchronous and remote data in Angular",
   "author": "Arnoud de Vries",
   "license": "MIT",
@@ -64,20 +64,22 @@
     "src"
   ],
   "dependencies": {
-    "@tanstack/query-core": "5.103.3"
+    "@tanstack/query-core": "5.104.0"
   },
   "devDependencies": {
+    "@analogjs/vite-plugin-angular": "^2.7.5",
     "@angular/common": "^20.0.0",
     "@angular/compiler": "^20.0.0",
     "@angular/core": "^20.0.0",
     "@angular/platform-browser": "^20.0.0",
+    "@oxc-project/runtime": "^0.151.0",
     "@tanstack/query-test-utils": "0.0.0",
     "@testing-library/angular": "^18.0.0",
     "npm-run-all2": "^9.0.3",
     "rxjs": "^7.8.2"
   },
   "optionalDependencies": {
-    "@tanstack/query-devtools": "5.103.3"
+    "@tanstack/query-devtools": "5.104.0"
   },
   "peerDependencies": {
     "@angular/common": ">=16.0.0",

package/src/create-base-query.ts

@@ -165,6 +165,7 @@ export function createBaseQuery<
       const originalRefetch = result.refetch
       return {
         ...result,
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
         refetch: ((...args: Parameters<typeof originalRefetch>) => {
           observer.setOptions(defaultedOptionsSignal())
           return originalRefetch(...args)

package/src/inject-queries.ts

@@ -400,6 +400,7 @@ export function injectQueries<
           ? 'isRestoring'
           : 'optimistic'
 
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
         return defaultedOptions as QueryObserverOptions
       })
     })