FRE-600: Fix code review blockers

- Consolidated duplicate UndoManagers to single instance
- Fixed connection promise to only resolve on 'connected' status
- Fixed WebSocketProvider import (WebsocketProvider)
- Added proper doc.destroy() cleanup
- Renamed isPresenceInitialized property to avoid conflict

Co-Authored-By: Paperclip <noreply@paperclip.ing>

node_modules/@tanstack/solid-query/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Tanner Linsley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/@tanstack/solid-query/README.md

@@ -0,0 +1,48 @@
+<img src="https://static.scarf.sh/a.png?x-pxid=be2d8a11-9712-4c1d-9963-580b2d4fb133" />
+
+![TanStack Query Header](https://github.com/TanStack/query/raw/main/media/repo-header.png)
+
+Hooks for fetching, caching and updating asynchronous data in Solid
+
+<a href="https://twitter.com/intent/tweet?button_hashtag=TanStack" target="\_parent">
+  <img alt="#TanStack" src="https://img.shields.io/twitter/url?color=%2308a0e9&label=%23TanStack&style=social&url=https%3A%2F%2Ftwitter.com%2Fintent%2Ftweet%3Fbutton_hashtag%3DTanStack">
+</a><a href="https://discord.com/invite/WrRKjPJ" target="\_parent">
+  <img alt="" src="https://img.shields.io/badge/Discord-TanStack-%235865F2" />
+</a><a href="https://github.com/TanStack/query/actions?query=workflow%3A%ci%22">
+<img src="https://github.com/TanStack/query/workflows/ci/badge.svg" />
+</a><a href="https://www.npmjs.com/package/@tanstack/query-core" target="\_parent">
+  <img alt="" src="https://img.shields.io/npm/dm/@tanstack/query-core.svg" />
+</a><a href="https://bundlejs.com/?q=%40tanstack%2Fsolid-query&config=%7B%22esbuild%22%3A%7B%22external%22%3A%5B%22solid-js%22%2C%5D%7D%7D&badge=" target="\_parent">
+  <img alt="" src="https://deno.bundlejs.com/?q=@tanstack/solid-query&config={%22esbuild%22:{%22external%22:[%22solid-js%22]}}&badge=detailed" />
+</a><a href="#badge">
+    <img alt="semantic-release" src="https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg">
+  </a><a href="https://github.com/TanStack/query/discussions">
+  <img alt="Join the discussion on Github" src="https://img.shields.io/badge/Github%20Discussions%20%26%20Support-Chat%20now!-blue" />
+</a><a href="https://bestofjs.org/projects/tanstack-query"><img alt="Best of JS" src="https://img.shields.io/endpoint?url=https://bestofjs-serverless.now.sh/api/project-badge?fullName=TanStack%2Fquery%26since=daily" /></a><a href="https://github.com/TanStack/query/" target="\_parent">
+  <img alt="" src="https://img.shields.io/github/stars/TanStack/query.svg?style=social&label=Star" />
+</a><a href="https://twitter.com/tannerlinsley" target="\_parent">
+  <img alt="" src="https://img.shields.io/twitter/follow/tannerlinsley.svg?style=social&label=Follow" />
+</a> <a href="https://gitpod.io/from-referrer/">
+  <img src="https://img.shields.io/badge/Gitpod-Ready--to--Code-blue?logo=gitpod" alt="Gitpod Ready-to-Code"/>
+</a>
+
+Enjoy this library? Try the entire [TanStack](https://tanstack.com)! [TanStack Table](https://github.com/TanStack/table), [TanStack Router](https://github.com/tanstack/router), [TanStack Virtual](https://github.com/tanstack/virtual)
+
+## Visit [tanstack.com/query](https://tanstack.com/query) for docs, guides, API and more!
+
+## Quick Features
+
+- Transport/protocol/backend agnostic data fetching (REST, GraphQL, promises, whatever!)
+- Auto Caching + Refetching (stale-while-revalidate, Window Refocus, Polling/Realtime)
+- Parallel + Dependent Queries
+- Mutations + Reactive Query Refetching
+- Multi-layer Cache + Automatic Garbage Collection
+- Paginated + Cursor-based Queries
+- Load-More + Infinite Scroll Queries w/ Scroll Recovery
+- Request Cancellation
+- Suspense + Fetch-As-You-Render Query Prefetching
+- Dedicated Devtools
+
+### [Become a Sponsor!](https://github.com/sponsors/tannerlinsley/)
+
+<!-- Use the force, Luke -->

node_modules/@tanstack/solid-query/build/_tsup-dts-rollup.d.cts

@@ -0,0 +1,788 @@
+import type { Accessor } from 'solid-js';
+import { AnyDataTag } from '@tanstack/query-core';
+import { CancelledError } from '@tanstack/query-core';
+import { CancelOptions } from '@tanstack/query-core';
+import { Context } from 'solid-js';
+import { ContextProviderComponent } from 'solid-js';
+import { DataTag } from '@tanstack/query-core';
+import { dataTagErrorSymbol } from '@tanstack/query-core';
+import { dataTagSymbol } from '@tanstack/query-core';
+import { DefaultedInfiniteQueryObserverOptions } from '@tanstack/query-core';
+import { DefaultedQueryObserverOptions } from '@tanstack/query-core';
+import { DefaultError } from '@tanstack/query-core';
+import type { DefaultOptions as DefaultOptions_2 } from '@tanstack/query-core';
+import { defaultScheduler } from '@tanstack/query-core';
+import { defaultShouldDehydrateMutation } from '@tanstack/query-core';
+import { defaultShouldDehydrateQuery } from '@tanstack/query-core';
+import { DefinedInfiniteQueryObserverResult } from '@tanstack/query-core';
+import { DefinedQueryObserverResult } from '@tanstack/query-core';
+import { dehydrate } from '@tanstack/query-core';
+import { DehydratedState } from '@tanstack/query-core';
+import { DehydrateOptions } from '@tanstack/query-core';
+import { DistributiveOmit } from '@tanstack/query-core';
+import { EnsureInfiniteQueryDataOptions } from '@tanstack/query-core';
+import { EnsureQueryDataOptions } from '@tanstack/query-core';
+import { environmentManager } from '@tanstack/query-core';
+import { experimental_streamedQuery } from '@tanstack/query-core';
+import { FetchInfiniteQueryOptions } from '@tanstack/query-core';
+import { FetchNextPageOptions } from '@tanstack/query-core';
+import { FetchPreviousPageOptions } from '@tanstack/query-core';
+import { FetchQueryOptions } from '@tanstack/query-core';
+import { FetchStatus } from '@tanstack/query-core';
+import { focusManager } from '@tanstack/query-core';
+import { GetNextPageParamFunction } from '@tanstack/query-core';
+import { GetPreviousPageParamFunction } from '@tanstack/query-core';
+import { hashKey } from '@tanstack/query-core';
+import { hydrate } from '@tanstack/query-core';
+import { HydrateOptions } from '@tanstack/query-core';
+import { InferDataFromTag } from '@tanstack/query-core';
+import { InferErrorFromTag } from '@tanstack/query-core';
+import { InfiniteData } from '@tanstack/query-core';
+import { InfiniteQueryObserver } from '@tanstack/query-core';
+import { InfiniteQueryObserverBaseResult } from '@tanstack/query-core';
+import { InfiniteQueryObserverLoadingErrorResult } from '@tanstack/query-core';
+import { InfiniteQueryObserverLoadingResult } from '@tanstack/query-core';
+import type { InfiniteQueryObserverOptions as InfiniteQueryObserverOptions_2 } from '@tanstack/query-core';
+import { InfiniteQueryObserverPendingResult } from '@tanstack/query-core';
+import { InfiniteQueryObserverPlaceholderResult } from '@tanstack/query-core';
+import { InfiniteQueryObserverRefetchErrorResult } from '@tanstack/query-core';
+import { InfiniteQueryObserverResult } from '@tanstack/query-core';
+import { InfiniteQueryObserverSuccessResult } from '@tanstack/query-core';
+import { InfiniteQueryPageParamsOptions } from '@tanstack/query-core';
+import { InitialDataFunction } from '@tanstack/query-core';
+import { InitialPageParam } from '@tanstack/query-core';
+import { InvalidateOptions } from '@tanstack/query-core';
+import { InvalidateQueryFilters } from '@tanstack/query-core';
+import { isCancelledError } from '@tanstack/query-core';
+import { isServer } from '@tanstack/query-core';
+import type { JSX } from 'solid-js';
+import { keepPreviousData } from '@tanstack/query-core';
+import { ManagedTimerId } from '@tanstack/query-core';
+import { matchMutation } from '@tanstack/query-core';
+import { matchQuery } from '@tanstack/query-core';
+import { MutateFunction } from '@tanstack/query-core';
+import { MutateOptions } from '@tanstack/query-core';
+import { Mutation } from '@tanstack/query-core';
+import { MutationCache } from '@tanstack/query-core';
+import { MutationCacheNotifyEvent } from '@tanstack/query-core';
+import { MutationFilters } from '@tanstack/query-core';
+import { MutationFunction } from '@tanstack/query-core';
+import { MutationFunctionContext } from '@tanstack/query-core';
+import { MutationKey } from '@tanstack/query-core';
+import { MutationMeta } from '@tanstack/query-core';
+import { MutationObserver as MutationObserver_2 } from '@tanstack/query-core';
+import { MutationObserverBaseResult } from '@tanstack/query-core';
+import { MutationObserverErrorResult } from '@tanstack/query-core';
+import { MutationObserverIdleResult } from '@tanstack/query-core';
+import { MutationObserverLoadingResult } from '@tanstack/query-core';
+import { MutationObserverOptions } from '@tanstack/query-core';
+import { MutationObserverResult } from '@tanstack/query-core';
+import { MutationObserverSuccessResult } from '@tanstack/query-core';
+import { MutationOptions } from '@tanstack/query-core';
+import { MutationScope } from '@tanstack/query-core';
+import { MutationState } from '@tanstack/query-core';
+import { MutationStatus } from '@tanstack/query-core';
+import { NetworkMode } from '@tanstack/query-core';
+import { NoInfer as NoInfer_2 } from '@tanstack/query-core';
+import { NonUndefinedGuard } from '@tanstack/query-core';
+import { noop } from '@tanstack/query-core';
+import { NotifyEvent } from '@tanstack/query-core';
+import { NotifyEventType } from '@tanstack/query-core';
+import { notifyManager } from '@tanstack/query-core';
+import { NotifyOnChangeProps } from '@tanstack/query-core';
+import { OmitKeyof } from '@tanstack/query-core';
+import { onlineManager } from '@tanstack/query-core';
+import { Override } from '@tanstack/query-core';
+import { partialMatchKey } from '@tanstack/query-core';
+import { PlaceholderDataFunction } from '@tanstack/query-core';
+import { QueriesObserver } from '@tanstack/query-core';
+import { QueriesObserverOptions } from '@tanstack/query-core';
+import { QueriesPlaceholderDataFunction } from '@tanstack/query-core';
+import { Query } from '@tanstack/query-core';
+import { QueryBooleanOption } from '@tanstack/query-core';
+import { QueryCache } from '@tanstack/query-core';
+import { QueryCacheNotifyEvent } from '@tanstack/query-core';
+import { QueryClient as QueryClient_2 } from '@tanstack/query-core';
+import type { QueryClientConfig as QueryClientConfig_2 } from '@tanstack/query-core';
+import { QueryFilters } from '@tanstack/query-core';
+import { QueryFunction } from '@tanstack/query-core';
+import { QueryFunctionContext } from '@tanstack/query-core';
+import { QueryKey } from '@tanstack/query-core';
+import { QueryKeyHashFunction } from '@tanstack/query-core';
+import { QueryMeta } from '@tanstack/query-core';
+import { QueryObserver } from '@tanstack/query-core';
+import { QueryObserverBaseResult } from '@tanstack/query-core';
+import { QueryObserverLoadingErrorResult } from '@tanstack/query-core';
+import { QueryObserverLoadingResult } from '@tanstack/query-core';
+import type { QueryObserverOptions as QueryObserverOptions_2 } from '@tanstack/query-core';
+import { QueryObserverPendingResult } from '@tanstack/query-core';
+import { QueryObserverPlaceholderResult } from '@tanstack/query-core';
+import { QueryObserverRefetchErrorResult } from '@tanstack/query-core';
+import { QueryObserverResult } from '@tanstack/query-core';
+import { QueryObserverSuccessResult } from '@tanstack/query-core';
+import { QueryOptions } from '@tanstack/query-core';
+import { QueryPersister } from '@tanstack/query-core';
+import { QueryState } from '@tanstack/query-core';
+import { QueryStatus } from '@tanstack/query-core';
+import { RefetchOptions } from '@tanstack/query-core';
+import { RefetchQueryFilters } from '@tanstack/query-core';
+import { Register } from '@tanstack/query-core';
+import { replaceEqualDeep } from '@tanstack/query-core';
+import { ResetOptions } from '@tanstack/query-core';
+import { ResultOptions } from '@tanstack/query-core';
+import { SetDataOptions } from '@tanstack/query-core';
+import { shouldThrowError } from '@tanstack/query-core';
+import { SkipToken } from '@tanstack/query-core';
+import { skipToken } from '@tanstack/query-core';
+import { StaleTime } from '@tanstack/query-core';
+import { StaleTimeFunction } from '@tanstack/query-core';
+import { ThrowOnError } from '@tanstack/query-core';
+import { TimeoutCallback } from '@tanstack/query-core';
+import { timeoutManager } from '@tanstack/query-core';
+import { TimeoutProvider } from '@tanstack/query-core';
+import { UnsetMarker } from '@tanstack/query-core';
+import { unsetMarker } from '@tanstack/query-core';
+import { Updater } from '@tanstack/query-core';
+import { WithRequired } from '@tanstack/query-core';
+
+export { AnyDataTag }
+
+export { CancelledError }
+
+export { CancelOptions }
+
+export declare const createInfiniteQuery: typeof useInfiniteQuery;
+
+export declare const createMutation: typeof useMutation;
+
+export declare const createQueries: typeof useQueries;
+
+export declare const createQuery: typeof useQuery;
+
+export { DataTag }
+
+export { dataTagErrorSymbol }
+
+export { dataTagSymbol }
+
+export { DefaultedInfiniteQueryObserverOptions }
+
+export { DefaultedQueryObserverOptions }
+
+export { DefaultError }
+
+declare interface DefaultOptions<TError = DefaultError> extends DefaultOptions_2<TError> {
+    queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'queryKey'>;
+}
+export { DefaultOptions }
+export { DefaultOptions as DefaultOptions_alias_1 }
+
+export { defaultScheduler }
+
+export { defaultShouldDehydrateMutation }
+
+export { defaultShouldDehydrateQuery }
+
+export { DefinedInfiniteQueryObserverResult }
+
+declare type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+    initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>);
+}>;
+export { DefinedInitialDataInfiniteOptions }
+export { DefinedInitialDataInfiniteOptions as DefinedInitialDataInfiniteOptions_alias_1 }
+
+declare type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    initialData: TQueryFnData | (() => TQueryFnData);
+}>;
+export { DefinedInitialDataOptions }
+export { DefinedInitialDataOptions as DefinedInitialDataOptions_alias_1 }
+
+export { DefinedQueryObserverResult }
+
+declare type DefinedUseBaseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
+export { DefinedUseBaseQueryResult as DefinedCreateBaseQueryResult }
+export { DefinedUseBaseQueryResult }
+export { DefinedUseBaseQueryResult as DefinedUseBaseQueryResult_alias_1 }
+
+declare type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
+export { DefinedUseInfiniteQueryResult as DefinedCreateInfiniteQueryResult }
+export { DefinedUseInfiniteQueryResult }
+export { DefinedUseInfiniteQueryResult as DefinedUseInfiniteQueryResult_alias_1 }
+
+declare type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedUseBaseQueryResult<TData, TError>;
+export { DefinedUseQueryResult as DefinedCreateQueryResult }
+export { DefinedUseQueryResult }
+export { DefinedUseQueryResult as DefinedUseQueryResult_alias_1 }
+
+export { dehydrate }
+
+export { DehydratedState }
+
+export { DehydrateOptions }
+
+export { DistributiveOmit }
+
+export { EnsureInfiniteQueryDataOptions }
+
+export { EnsureQueryDataOptions }
+
+export { environmentManager }
+
+export { experimental_streamedQuery }
+
+export { FetchInfiniteQueryOptions }
+
+export { FetchNextPageOptions }
+
+export { FetchPreviousPageOptions }
+
+export { FetchQueryOptions }
+
+export { FetchStatus }
+
+export { focusManager }
+
+export { GetNextPageParamFunction }
+
+declare type GetOptions<T> = T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+    data: infer TData;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForUseQueries;
+    select?: (data: any) => infer TData;
+    throwOnError?: ThrowOnError<any, infer TError, any, any>;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : UseQueryOptionsForUseQueries;
+
+export { GetPreviousPageParamFunction }
+
+declare type GetResults<T> = T extends {
+    queryFnData: any;
+    error?: infer TError;
+    data: infer TData;
+} ? UseQueryResult<TData, TError> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? UseQueryResult<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? UseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryResult<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForUseQueries;
+    select?: (data: any) => infer TData;
+    throwOnError?: ThrowOnError<any, infer TError, any, any>;
+} ? UseQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : UseQueryResult;
+
+export { hashKey }
+
+export { hydrate }
+
+export { HydrateOptions }
+
+export { InferDataFromTag }
+
+export { InferErrorFromTag }
+
+export { InfiniteData }
+
+export { InfiniteQueryObserver }
+
+export { InfiniteQueryObserverBaseResult }
+
+export { InfiniteQueryObserverLoadingErrorResult }
+
+export { InfiniteQueryObserverLoadingResult }
+
+declare interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions_2<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'structuralSharing'> {
+    /**
+     * Set this to a reconciliation key to enable reconciliation between query results.
+     * Set this to `false` to disable reconciliation between query results.
+     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+     * Defaults reconciliation to false.
+     */
+    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
+}
+export { InfiniteQueryObserverOptions }
+export { InfiniteQueryObserverOptions as InfiniteQueryObserverOptions_alias_1 }
+
+export { InfiniteQueryObserverPendingResult }
+
+export { InfiniteQueryObserverPlaceholderResult }
+
+export { InfiniteQueryObserverRefetchErrorResult }
+
+export { InfiniteQueryObserverResult }
+
+export { InfiniteQueryObserverSuccessResult }
+
+declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: ReturnType<DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>): ReturnType<DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>> & {
+    queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>;
+};
+
+declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: ReturnType<UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>): ReturnType<UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>> & {
+    queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>;
+};
+export { infiniteQueryOptions }
+export { infiniteQueryOptions as infiniteQueryOptions_alias_1 }
+
+export { InfiniteQueryPageParamsOptions }
+
+export { InitialDataFunction }
+
+export { InitialPageParam }
+
+export { InvalidateOptions }
+
+export { InvalidateQueryFilters }
+
+export { isCancelledError }
+
+declare const IsRestoringProvider: ContextProviderComponent<Accessor<boolean>>;
+export { IsRestoringProvider }
+export { IsRestoringProvider as IsRestoringProvider_alias_1 }
+
+export { isServer }
+
+export { keepPreviousData }
+
+export { ManagedTimerId }
+
+export { matchMutation }
+
+export { matchQuery }
+
+declare type MAXIMUM_DEPTH = 20;
+
+export { MutateFunction }
+
+export { MutateOptions }
+
+export { Mutation }
+
+export { MutationCache }
+
+export { MutationCacheNotifyEvent }
+
+export { MutationFilters }
+
+export { MutationFunction }
+
+export { MutationFunctionContext }
+
+export { MutationKey }
+
+export { MutationMeta }
+
+export { MutationObserver_2 as MutationObserver }
+
+export { MutationObserverBaseResult }
+
+export { MutationObserverErrorResult }
+
+export { MutationObserverIdleResult }
+
+export { MutationObserverLoadingResult }
+
+export { MutationObserverOptions }
+
+export { MutationObserverResult }
+
+export { MutationObserverSuccessResult }
+
+export { MutationOptions }
+
+declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
+
+declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
+export { mutationOptions }
+export { mutationOptions as mutationOptions_alias_1 }
+
+export { MutationScope }
+
+export { MutationState }
+
+declare type MutationStateOptions<TResult = MutationState> = {
+    filters?: MutationFilters;
+    select?: (mutation: Mutation) => TResult;
+};
+
+export { MutationStatus }
+
+export { NetworkMode }
+
+export { NoInfer_2 as NoInfer }
+
+export { NonUndefinedGuard }
+
+export { noop }
+
+export { NotifyEvent }
+
+export { NotifyEventType }
+
+export { notifyManager }
+
+export { NotifyOnChangeProps }
+
+export { OmitKeyof }
+
+export { onlineManager }
+
+export { Override }
+
+export { partialMatchKey }
+
+export { PlaceholderDataFunction }
+
+export { QueriesObserver }
+
+export { QueriesObserverOptions }
+
+/**
+ * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ */
+declare type QueriesOptions<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[
+...Tail
+], [
+...TResult,
+GetOptions<Head>
+], [
+...TDepth,
+1
+]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;
+
+export { QueriesPlaceholderDataFunction }
+
+/**
+ * QueriesResults reducer recursively maps type param to results
+ */
+declare type QueriesResults<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[
+...Tail
+], [
+...TResult,
+GetResults<Head>
+], [
+...TDepth,
+1
+]> : {
+    [K in keyof T]: GetResults<T[K]>;
+};
+
+export { Query }
+
+export { QueryBooleanOption }
+
+export { QueryCache }
+
+export { QueryCacheNotifyEvent }
+
+declare class QueryClient extends QueryClient_2 {
+    constructor(config?: QueryClientConfig);
+}
+export { QueryClient }
+export { QueryClient as QueryClient_alias_1 }
+
+declare interface QueryClientConfig extends QueryClientConfig_2 {
+    defaultOptions?: DefaultOptions;
+}
+export { QueryClientConfig }
+export { QueryClientConfig as QueryClientConfig_alias_1 }
+
+declare const QueryClientContext: Context<(() => QueryClient) | undefined>;
+export { QueryClientContext }
+export { QueryClientContext as QueryClientContext_alias_1 }
+
+declare const QueryClientProvider: (props: QueryClientProviderProps) => JSX.Element;
+export { QueryClientProvider }
+export { QueryClientProvider as QueryClientProvider_alias_1 }
+
+declare type QueryClientProviderProps = {
+    client: QueryClient;
+    children?: JSX.Element;
+};
+export { QueryClientProviderProps }
+export { QueryClientProviderProps as QueryClientProviderProps_alias_1 }
+
+export { QueryFilters }
+
+export { QueryFunction }
+
+export { QueryFunctionContext }
+
+export { QueryKey }
+
+export { QueryKeyHashFunction }
+
+export { QueryMeta }
+
+export { QueryObserver }
+
+export { QueryObserverBaseResult }
+
+export { QueryObserverLoadingErrorResult }
+
+export { QueryObserverLoadingResult }
+
+declare interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends OmitKeyof<QueryObserverOptions_2<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'structuralSharing'> {
+    /**
+     * Set this to a reconciliation key to enable reconciliation between query results.
+     * Set this to `false` to disable reconciliation between query results.
+     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+     * Defaults reconciliation to false.
+     */
+    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
+}
+export { QueryObserverOptions }
+export { QueryObserverOptions as QueryObserverOptions_alias_1 }
+
+export { QueryObserverPendingResult }
+
+export { QueryObserverPlaceholderResult }
+
+export { QueryObserverRefetchErrorResult }
+
+export { QueryObserverResult }
+
+export { QueryObserverSuccessResult }
+
+export { QueryOptions }
+
+declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: ReturnType<UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>>): ReturnType<UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>> & {
+    queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
+};
+
+declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: ReturnType<DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>>): ReturnType<DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>> & {
+    queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
+};
+export { queryOptions }
+export { queryOptions as queryOptions_alias_1 }
+
+export { QueryPersister }
+
+export { QueryState }
+
+export { QueryStatus }
+
+export { RefetchOptions }
+
+export { RefetchQueryFilters }
+
+export { Register }
+
+export { replaceEqualDeep }
+
+export { ResetOptions }
+
+export { ResultOptions }
+
+export { SetDataOptions }
+
+export { shouldThrowError }
+
+export { SkipToken }
+
+export { skipToken }
+
+declare type SkipTokenForUseQueries = symbol;
+
+declare interface SolidInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryKey' | 'suspense'> {
+    queryKey: TQueryKey;
+    /**
+     * Only applicable while rendering queries on the server with streaming.
+     * Set `deferStream` to `true` to wait for the query to resolve on the server before flushing the stream.
+     * This can be useful to avoid sending a loading state to the client before the query has resolved.
+     * Defaults to `false`.
+     */
+    deferStream?: boolean;
+    /**
+     * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
+     * The `data` property on useInfiniteQuery is a SolidJS resource and will automatically suspend when the data is loading.
+     * Setting `suspense` to `false` will be a no-op.
+     */
+    suspense?: boolean;
+}
+export { SolidInfiniteQueryOptions }
+export { SolidInfiniteQueryOptions as SolidInfiniteQueryOptions_alias_1 }
+
+declare interface SolidMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {
+}
+export { SolidMutationOptions }
+export { SolidMutationOptions as SolidMutationOptions_alias_1 }
+
+declare interface SolidQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> {
+}
+export { SolidQueryOptions }
+export { SolidQueryOptions as SolidQueryOptions_alias_1 }
+
+export { StaleTime }
+
+export { StaleTimeFunction }
+
+export { ThrowOnError }
+
+export { TimeoutCallback }
+
+export { timeoutManager }
+
+export { TimeoutProvider }
+
+declare type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+    initialData?: undefined;
+}>;
+export { UndefinedInitialDataInfiniteOptions }
+export { UndefinedInitialDataInfiniteOptions as UndefinedInitialDataInfiniteOptions_alias_1 }
+
+declare type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    initialData?: undefined;
+}>;
+export { UndefinedInitialDataOptions }
+export { UndefinedInitialDataOptions as UndefinedInitialDataOptions_alias_1 }
+
+export { UnsetMarker }
+
+export { unsetMarker }
+
+export { Updater }
+
+declare type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, {
+    mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult>;
+}> & {
+    mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TOnMutateResult>;
+};
+export { UseBaseMutationResult as CreateBaseMutationResult }
+export { UseBaseMutationResult }
+export { UseBaseMutationResult as UseBaseMutationResult_alias_1 }
+
+export declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: Accessor<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>>, Observer: typeof QueryObserver, queryClient?: Accessor<QueryClient>): QueryObserverResult<TData, TError>;
+
+declare interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'suspense'> {
+    /**
+     * Only applicable while rendering queries on the server with streaming.
+     * Set `deferStream` to `true` to wait for the query to resolve on the server before flushing the stream.
+     * This can be useful to avoid sending a loading state to the client before the query has resolved.
+     * Defaults to `false`.
+     */
+    deferStream?: boolean;
+    /**
+     * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
+     * The `data` property on useQuery is a SolidJS resource and will automatically suspend when the data is loading.
+     * Setting `suspense` to `false` will be a no-op.
+     */
+    suspense?: boolean;
+}
+export { UseBaseQueryOptions as CreateBaseQueryOptions }
+export { UseBaseQueryOptions }
+export { UseBaseQueryOptions as UseBaseQueryOptions_alias_1 }
+
+declare type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
+export { UseBaseQueryResult as CreateBaseQueryResult }
+export { UseBaseQueryResult }
+export { UseBaseQueryResult as UseBaseQueryResult_alias_1 }
+
+declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): DefinedUseInfiniteQueryResult<TData, TError>;
+
+declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): UseInfiniteQueryResult<TData, TError>;
+export { useInfiniteQuery }
+export { useInfiniteQuery as useInfiniteQuery_alias_1 }
+
+declare type UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>;
+export { UseInfiniteQueryOptions as CreateInfiniteQueryOptions }
+export { UseInfiniteQueryOptions }
+export { UseInfiniteQueryOptions as UseInfiniteQueryOptions_alias_1 }
+
+declare type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
+export { UseInfiniteQueryResult as CreateInfiniteQueryResult }
+export { UseInfiniteQueryResult }
+export { UseInfiniteQueryResult as UseInfiniteQueryResult_alias_1 }
+
+declare function useIsFetching(filters?: Accessor<QueryFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
+export { useIsFetching as createIsFetching }
+export { useIsFetching }
+export { useIsFetching as useIsFetching_alias_1 }
+
+declare function useIsMutating(filters?: Accessor<MutationFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
+export { useIsMutating as createIsMutating }
+export { useIsMutating }
+export { useIsMutating as useIsMutating_alias_1 }
+
+declare const useIsRestoring: () => Accessor<boolean>;
+export { useIsRestoring }
+export { useIsRestoring as useIsRestoring_alias_1 }
+
+declare type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutateFunction<TData, TError, TVariables, TOnMutateResult>;
+export { UseMutateAsyncFunction as CreateMutateAsyncFunction }
+export { UseMutateAsyncFunction }
+export { UseMutateAsyncFunction as UseMutateAsyncFunction_alias_1 }
+
+declare type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
+export { UseMutateFunction as CreateMutateFunction }
+export { UseMutateFunction }
+export { UseMutateFunction as UseMutateFunction_alias_1 }
+
+declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: Accessor<QueryClient>): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
+export { useMutation }
+export { useMutation as useMutation_alias_1 }
+
+declare type UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = Accessor<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>>;
+export { UseMutationOptions as CreateMutationOptions }
+export { UseMutationOptions }
+export { UseMutationOptions as UseMutationOptions_alias_1 }
+
+declare type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>;
+export { UseMutationResult as CreateMutationResult }
+export { UseMutationResult }
+export { UseMutationResult as UseMutationResult_alias_1 }
+
+declare function useMutationState<TResult = MutationState>(options?: Accessor<MutationStateOptions<TResult>>, queryClient?: Accessor<QueryClient>): Accessor<Array<TResult>>;
+export { useMutationState as createMutationState }
+export { useMutationState }
+export { useMutationState as useMutationState_alias_1 }
+
+declare function useQueries<T extends Array<any>, TCombinedResult extends QueriesResults<T> = QueriesResults<T>>(queriesOptions: Accessor<{
+    queries: readonly [...QueriesOptions<T>] | readonly [...{
+        [K in keyof T]: GetOptions<T[K]>;
+    }];
+    combine?: (result: QueriesResults<T>) => TCombinedResult;
+}>, queryClient?: Accessor<QueryClient>): TCombinedResult;
+export { useQueries }
+export { useQueries as useQueries_alias_1 }
+
+declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): UseQueryResult<TData, TError>;
+
+declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): DefinedUseQueryResult<TData, TError>;
+export { useQuery }
+export { useQuery as useQuery_alias_1 }
+
+declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
+export { useQueryClient }
+export { useQueryClient as useQueryClient_alias_1 }
+
+declare type UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>>;
+export { UseQueryOptions as CreateQueryOptions }
+export { UseQueryOptions }
+export { UseQueryOptions as UseQueryOptions_alias_1 }
+
+declare type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' | 'suspense'> & {
+    placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
+    /**
+     * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
+     * The `data` property on useQueries is a plain object and not a SolidJS Resource.
+     * It will not suspend when the data is loading.
+     * Setting `suspense` to `true` will be a no-op.
+     */
+    suspense?: boolean;
+};
+
+declare type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
+export { UseQueryResult as CreateQueryResult }
+export { UseQueryResult }
+export { UseQueryResult as UseQueryResult_alias_1 }
+
+export { WithRequired }
+
+export { }

node_modules/@tanstack/solid-query/build/_tsup-dts-rollup.d.ts

@@ -0,0 +1,788 @@
+import type { Accessor } from 'solid-js';
+import { AnyDataTag } from '@tanstack/query-core';
+import { CancelledError } from '@tanstack/query-core';
+import { CancelOptions } from '@tanstack/query-core';
+import { Context } from 'solid-js';
+import { ContextProviderComponent } from 'solid-js';
+import { DataTag } from '@tanstack/query-core';
+import { dataTagErrorSymbol } from '@tanstack/query-core';
+import { dataTagSymbol } from '@tanstack/query-core';
+import { DefaultedInfiniteQueryObserverOptions } from '@tanstack/query-core';
+import { DefaultedQueryObserverOptions } from '@tanstack/query-core';
+import { DefaultError } from '@tanstack/query-core';
+import type { DefaultOptions as DefaultOptions_2 } from '@tanstack/query-core';
+import { defaultScheduler } from '@tanstack/query-core';
+import { defaultShouldDehydrateMutation } from '@tanstack/query-core';
+import { defaultShouldDehydrateQuery } from '@tanstack/query-core';
+import { DefinedInfiniteQueryObserverResult } from '@tanstack/query-core';
+import { DefinedQueryObserverResult } from '@tanstack/query-core';
+import { dehydrate } from '@tanstack/query-core';
+import { DehydratedState } from '@tanstack/query-core';
+import { DehydrateOptions } from '@tanstack/query-core';
+import { DistributiveOmit } from '@tanstack/query-core';
+import { EnsureInfiniteQueryDataOptions } from '@tanstack/query-core';
+import { EnsureQueryDataOptions } from '@tanstack/query-core';
+import { environmentManager } from '@tanstack/query-core';
+import { experimental_streamedQuery } from '@tanstack/query-core';
+import { FetchInfiniteQueryOptions } from '@tanstack/query-core';
+import { FetchNextPageOptions } from '@tanstack/query-core';
+import { FetchPreviousPageOptions } from '@tanstack/query-core';
+import { FetchQueryOptions } from '@tanstack/query-core';
+import { FetchStatus } from '@tanstack/query-core';
+import { focusManager } from '@tanstack/query-core';
+import { GetNextPageParamFunction } from '@tanstack/query-core';
+import { GetPreviousPageParamFunction } from '@tanstack/query-core';
+import { hashKey } from '@tanstack/query-core';
+import { hydrate } from '@tanstack/query-core';
+import { HydrateOptions } from '@tanstack/query-core';
+import { InferDataFromTag } from '@tanstack/query-core';
+import { InferErrorFromTag } from '@tanstack/query-core';
+import { InfiniteData } from '@tanstack/query-core';
+import { InfiniteQueryObserver } from '@tanstack/query-core';
+import { InfiniteQueryObserverBaseResult } from '@tanstack/query-core';
+import { InfiniteQueryObserverLoadingErrorResult } from '@tanstack/query-core';
+import { InfiniteQueryObserverLoadingResult } from '@tanstack/query-core';
+import type { InfiniteQueryObserverOptions as InfiniteQueryObserverOptions_2 } from '@tanstack/query-core';
+import { InfiniteQueryObserverPendingResult } from '@tanstack/query-core';
+import { InfiniteQueryObserverPlaceholderResult } from '@tanstack/query-core';
+import { InfiniteQueryObserverRefetchErrorResult } from '@tanstack/query-core';
+import { InfiniteQueryObserverResult } from '@tanstack/query-core';
+import { InfiniteQueryObserverSuccessResult } from '@tanstack/query-core';
+import { InfiniteQueryPageParamsOptions } from '@tanstack/query-core';
+import { InitialDataFunction } from '@tanstack/query-core';
+import { InitialPageParam } from '@tanstack/query-core';
+import { InvalidateOptions } from '@tanstack/query-core';
+import { InvalidateQueryFilters } from '@tanstack/query-core';
+import { isCancelledError } from '@tanstack/query-core';
+import { isServer } from '@tanstack/query-core';
+import type { JSX } from 'solid-js';
+import { keepPreviousData } from '@tanstack/query-core';
+import { ManagedTimerId } from '@tanstack/query-core';
+import { matchMutation } from '@tanstack/query-core';
+import { matchQuery } from '@tanstack/query-core';
+import { MutateFunction } from '@tanstack/query-core';
+import { MutateOptions } from '@tanstack/query-core';
+import { Mutation } from '@tanstack/query-core';
+import { MutationCache } from '@tanstack/query-core';
+import { MutationCacheNotifyEvent } from '@tanstack/query-core';
+import { MutationFilters } from '@tanstack/query-core';
+import { MutationFunction } from '@tanstack/query-core';
+import { MutationFunctionContext } from '@tanstack/query-core';
+import { MutationKey } from '@tanstack/query-core';
+import { MutationMeta } from '@tanstack/query-core';
+import { MutationObserver as MutationObserver_2 } from '@tanstack/query-core';
+import { MutationObserverBaseResult } from '@tanstack/query-core';
+import { MutationObserverErrorResult } from '@tanstack/query-core';
+import { MutationObserverIdleResult } from '@tanstack/query-core';
+import { MutationObserverLoadingResult } from '@tanstack/query-core';
+import { MutationObserverOptions } from '@tanstack/query-core';
+import { MutationObserverResult } from '@tanstack/query-core';
+import { MutationObserverSuccessResult } from '@tanstack/query-core';
+import { MutationOptions } from '@tanstack/query-core';
+import { MutationScope } from '@tanstack/query-core';
+import { MutationState } from '@tanstack/query-core';
+import { MutationStatus } from '@tanstack/query-core';
+import { NetworkMode } from '@tanstack/query-core';
+import { NoInfer as NoInfer_2 } from '@tanstack/query-core';
+import { NonUndefinedGuard } from '@tanstack/query-core';
+import { noop } from '@tanstack/query-core';
+import { NotifyEvent } from '@tanstack/query-core';
+import { NotifyEventType } from '@tanstack/query-core';
+import { notifyManager } from '@tanstack/query-core';
+import { NotifyOnChangeProps } from '@tanstack/query-core';
+import { OmitKeyof } from '@tanstack/query-core';
+import { onlineManager } from '@tanstack/query-core';
+import { Override } from '@tanstack/query-core';
+import { partialMatchKey } from '@tanstack/query-core';
+import { PlaceholderDataFunction } from '@tanstack/query-core';
+import { QueriesObserver } from '@tanstack/query-core';
+import { QueriesObserverOptions } from '@tanstack/query-core';
+import { QueriesPlaceholderDataFunction } from '@tanstack/query-core';
+import { Query } from '@tanstack/query-core';
+import { QueryBooleanOption } from '@tanstack/query-core';
+import { QueryCache } from '@tanstack/query-core';
+import { QueryCacheNotifyEvent } from '@tanstack/query-core';
+import { QueryClient as QueryClient_2 } from '@tanstack/query-core';
+import type { QueryClientConfig as QueryClientConfig_2 } from '@tanstack/query-core';
+import { QueryFilters } from '@tanstack/query-core';
+import { QueryFunction } from '@tanstack/query-core';
+import { QueryFunctionContext } from '@tanstack/query-core';
+import { QueryKey } from '@tanstack/query-core';
+import { QueryKeyHashFunction } from '@tanstack/query-core';
+import { QueryMeta } from '@tanstack/query-core';
+import { QueryObserver } from '@tanstack/query-core';
+import { QueryObserverBaseResult } from '@tanstack/query-core';
+import { QueryObserverLoadingErrorResult } from '@tanstack/query-core';
+import { QueryObserverLoadingResult } from '@tanstack/query-core';
+import type { QueryObserverOptions as QueryObserverOptions_2 } from '@tanstack/query-core';
+import { QueryObserverPendingResult } from '@tanstack/query-core';
+import { QueryObserverPlaceholderResult } from '@tanstack/query-core';
+import { QueryObserverRefetchErrorResult } from '@tanstack/query-core';
+import { QueryObserverResult } from '@tanstack/query-core';
+import { QueryObserverSuccessResult } from '@tanstack/query-core';
+import { QueryOptions } from '@tanstack/query-core';
+import { QueryPersister } from '@tanstack/query-core';
+import { QueryState } from '@tanstack/query-core';
+import { QueryStatus } from '@tanstack/query-core';
+import { RefetchOptions } from '@tanstack/query-core';
+import { RefetchQueryFilters } from '@tanstack/query-core';
+import { Register } from '@tanstack/query-core';
+import { replaceEqualDeep } from '@tanstack/query-core';
+import { ResetOptions } from '@tanstack/query-core';
+import { ResultOptions } from '@tanstack/query-core';
+import { SetDataOptions } from '@tanstack/query-core';
+import { shouldThrowError } from '@tanstack/query-core';
+import { SkipToken } from '@tanstack/query-core';
+import { skipToken } from '@tanstack/query-core';
+import { StaleTime } from '@tanstack/query-core';
+import { StaleTimeFunction } from '@tanstack/query-core';
+import { ThrowOnError } from '@tanstack/query-core';
+import { TimeoutCallback } from '@tanstack/query-core';
+import { timeoutManager } from '@tanstack/query-core';
+import { TimeoutProvider } from '@tanstack/query-core';
+import { UnsetMarker } from '@tanstack/query-core';
+import { unsetMarker } from '@tanstack/query-core';
+import { Updater } from '@tanstack/query-core';
+import { WithRequired } from '@tanstack/query-core';
+
+export { AnyDataTag }
+
+export { CancelledError }
+
+export { CancelOptions }
+
+export declare const createInfiniteQuery: typeof useInfiniteQuery;
+
+export declare const createMutation: typeof useMutation;
+
+export declare const createQueries: typeof useQueries;
+
+export declare const createQuery: typeof useQuery;
+
+export { DataTag }
+
+export { dataTagErrorSymbol }
+
+export { dataTagSymbol }
+
+export { DefaultedInfiniteQueryObserverOptions }
+
+export { DefaultedQueryObserverOptions }
+
+export { DefaultError }
+
+declare interface DefaultOptions<TError = DefaultError> extends DefaultOptions_2<TError> {
+    queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'queryKey'>;
+}
+export { DefaultOptions }
+export { DefaultOptions as DefaultOptions_alias_1 }
+
+export { defaultScheduler }
+
+export { defaultShouldDehydrateMutation }
+
+export { defaultShouldDehydrateQuery }
+
+export { DefinedInfiniteQueryObserverResult }
+
+declare type DefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+    initialData: NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>> | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>);
+}>;
+export { DefinedInitialDataInfiniteOptions }
+export { DefinedInitialDataInfiniteOptions as DefinedInitialDataInfiniteOptions_alias_1 }
+
+declare type DefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    initialData: TQueryFnData | (() => TQueryFnData);
+}>;
+export { DefinedInitialDataOptions }
+export { DefinedInitialDataOptions as DefinedInitialDataOptions_alias_1 }
+
+export { DefinedQueryObserverResult }
+
+declare type DefinedUseBaseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
+export { DefinedUseBaseQueryResult as DefinedCreateBaseQueryResult }
+export { DefinedUseBaseQueryResult }
+export { DefinedUseBaseQueryResult as DefinedUseBaseQueryResult_alias_1 }
+
+declare type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
+export { DefinedUseInfiniteQueryResult as DefinedCreateInfiniteQueryResult }
+export { DefinedUseInfiniteQueryResult }
+export { DefinedUseInfiniteQueryResult as DefinedUseInfiniteQueryResult_alias_1 }
+
+declare type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedUseBaseQueryResult<TData, TError>;
+export { DefinedUseQueryResult as DefinedCreateQueryResult }
+export { DefinedUseQueryResult }
+export { DefinedUseQueryResult as DefinedUseQueryResult_alias_1 }
+
+export { dehydrate }
+
+export { DehydratedState }
+
+export { DehydrateOptions }
+
+export { DistributiveOmit }
+
+export { EnsureInfiniteQueryDataOptions }
+
+export { EnsureQueryDataOptions }
+
+export { environmentManager }
+
+export { experimental_streamedQuery }
+
+export { FetchInfiniteQueryOptions }
+
+export { FetchNextPageOptions }
+
+export { FetchPreviousPageOptions }
+
+export { FetchQueryOptions }
+
+export { FetchStatus }
+
+export { focusManager }
+
+export { GetNextPageParamFunction }
+
+declare type GetOptions<T> = T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+    data: infer TData;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForUseQueries;
+    select?: (data: any) => infer TData;
+    throwOnError?: ThrowOnError<any, infer TError, any, any>;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : UseQueryOptionsForUseQueries;
+
+export { GetPreviousPageParamFunction }
+
+declare type GetResults<T> = T extends {
+    queryFnData: any;
+    error?: infer TError;
+    data: infer TData;
+} ? UseQueryResult<TData, TError> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? UseQueryResult<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? UseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryResult<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForUseQueries;
+    select?: (data: any) => infer TData;
+    throwOnError?: ThrowOnError<any, infer TError, any, any>;
+} ? UseQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : UseQueryResult;
+
+export { hashKey }
+
+export { hydrate }
+
+export { HydrateOptions }
+
+export { InferDataFromTag }
+
+export { InferErrorFromTag }
+
+export { InfiniteData }
+
+export { InfiniteQueryObserver }
+
+export { InfiniteQueryObserverBaseResult }
+
+export { InfiniteQueryObserverLoadingErrorResult }
+
+export { InfiniteQueryObserverLoadingResult }
+
+declare interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions_2<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'structuralSharing'> {
+    /**
+     * Set this to a reconciliation key to enable reconciliation between query results.
+     * Set this to `false` to disable reconciliation between query results.
+     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+     * Defaults reconciliation to false.
+     */
+    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
+}
+export { InfiniteQueryObserverOptions }
+export { InfiniteQueryObserverOptions as InfiniteQueryObserverOptions_alias_1 }
+
+export { InfiniteQueryObserverPendingResult }
+
+export { InfiniteQueryObserverPlaceholderResult }
+
+export { InfiniteQueryObserverRefetchErrorResult }
+
+export { InfiniteQueryObserverResult }
+
+export { InfiniteQueryObserverSuccessResult }
+
+declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: ReturnType<DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>): ReturnType<DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>> & {
+    queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>;
+};
+
+declare function infiniteQueryOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: ReturnType<UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>): ReturnType<UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>> & {
+    queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>;
+};
+export { infiniteQueryOptions }
+export { infiniteQueryOptions as infiniteQueryOptions_alias_1 }
+
+export { InfiniteQueryPageParamsOptions }
+
+export { InitialDataFunction }
+
+export { InitialPageParam }
+
+export { InvalidateOptions }
+
+export { InvalidateQueryFilters }
+
+export { isCancelledError }
+
+declare const IsRestoringProvider: ContextProviderComponent<Accessor<boolean>>;
+export { IsRestoringProvider }
+export { IsRestoringProvider as IsRestoringProvider_alias_1 }
+
+export { isServer }
+
+export { keepPreviousData }
+
+export { ManagedTimerId }
+
+export { matchMutation }
+
+export { matchQuery }
+
+declare type MAXIMUM_DEPTH = 20;
+
+export { MutateFunction }
+
+export { MutateOptions }
+
+export { Mutation }
+
+export { MutationCache }
+
+export { MutationCacheNotifyEvent }
+
+export { MutationFilters }
+
+export { MutationFunction }
+
+export { MutationFunctionContext }
+
+export { MutationKey }
+
+export { MutationMeta }
+
+export { MutationObserver_2 as MutationObserver }
+
+export { MutationObserverBaseResult }
+
+export { MutationObserverErrorResult }
+
+export { MutationObserverIdleResult }
+
+export { MutationObserverLoadingResult }
+
+export { MutationObserverOptions }
+
+export { MutationObserverResult }
+
+export { MutationObserverSuccessResult }
+
+export { MutationOptions }
+
+declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: WithRequired<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): WithRequired<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
+
+declare function mutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: Omit<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>): Omit<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>, 'mutationKey'>;
+export { mutationOptions }
+export { mutationOptions as mutationOptions_alias_1 }
+
+export { MutationScope }
+
+export { MutationState }
+
+declare type MutationStateOptions<TResult = MutationState> = {
+    filters?: MutationFilters;
+    select?: (mutation: Mutation) => TResult;
+};
+
+export { MutationStatus }
+
+export { NetworkMode }
+
+export { NoInfer_2 as NoInfer }
+
+export { NonUndefinedGuard }
+
+export { noop }
+
+export { NotifyEvent }
+
+export { NotifyEventType }
+
+export { notifyManager }
+
+export { NotifyOnChangeProps }
+
+export { OmitKeyof }
+
+export { onlineManager }
+
+export { Override }
+
+export { partialMatchKey }
+
+export { PlaceholderDataFunction }
+
+export { QueriesObserver }
+
+export { QueriesObserverOptions }
+
+/**
+ * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ */
+declare type QueriesOptions<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[
+...Tail
+], [
+...TResult,
+GetOptions<Head>
+], [
+...TDepth,
+1
+]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;
+
+export { QueriesPlaceholderDataFunction }
+
+/**
+ * QueriesResults reducer recursively maps type param to results
+ */
+declare type QueriesResults<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[
+...Tail
+], [
+...TResult,
+GetResults<Head>
+], [
+...TDepth,
+1
+]> : {
+    [K in keyof T]: GetResults<T[K]>;
+};
+
+export { Query }
+
+export { QueryBooleanOption }
+
+export { QueryCache }
+
+export { QueryCacheNotifyEvent }
+
+declare class QueryClient extends QueryClient_2 {
+    constructor(config?: QueryClientConfig);
+}
+export { QueryClient }
+export { QueryClient as QueryClient_alias_1 }
+
+declare interface QueryClientConfig extends QueryClientConfig_2 {
+    defaultOptions?: DefaultOptions;
+}
+export { QueryClientConfig }
+export { QueryClientConfig as QueryClientConfig_alias_1 }
+
+declare const QueryClientContext: Context<(() => QueryClient) | undefined>;
+export { QueryClientContext }
+export { QueryClientContext as QueryClientContext_alias_1 }
+
+declare const QueryClientProvider: (props: QueryClientProviderProps) => JSX.Element;
+export { QueryClientProvider }
+export { QueryClientProvider as QueryClientProvider_alias_1 }
+
+declare type QueryClientProviderProps = {
+    client: QueryClient;
+    children?: JSX.Element;
+};
+export { QueryClientProviderProps }
+export { QueryClientProviderProps as QueryClientProviderProps_alias_1 }
+
+export { QueryFilters }
+
+export { QueryFunction }
+
+export { QueryFunctionContext }
+
+export { QueryKey }
+
+export { QueryKeyHashFunction }
+
+export { QueryMeta }
+
+export { QueryObserver }
+
+export { QueryObserverBaseResult }
+
+export { QueryObserverLoadingErrorResult }
+
+export { QueryObserverLoadingResult }
+
+declare interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends OmitKeyof<QueryObserverOptions_2<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'structuralSharing'> {
+    /**
+     * Set this to a reconciliation key to enable reconciliation between query results.
+     * Set this to `false` to disable reconciliation between query results.
+     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+     * Defaults reconciliation to false.
+     */
+    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
+}
+export { QueryObserverOptions }
+export { QueryObserverOptions as QueryObserverOptions_alias_1 }
+
+export { QueryObserverPendingResult }
+
+export { QueryObserverPlaceholderResult }
+
+export { QueryObserverRefetchErrorResult }
+
+export { QueryObserverResult }
+
+export { QueryObserverSuccessResult }
+
+export { QueryOptions }
+
+declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: ReturnType<UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>>): ReturnType<UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>> & {
+    queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
+};
+
+declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: ReturnType<DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>>): ReturnType<DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>> & {
+    queryKey: DataTag<TQueryKey, TQueryFnData, TError>;
+};
+export { queryOptions }
+export { queryOptions as queryOptions_alias_1 }
+
+export { QueryPersister }
+
+export { QueryState }
+
+export { QueryStatus }
+
+export { RefetchOptions }
+
+export { RefetchQueryFilters }
+
+export { Register }
+
+export { replaceEqualDeep }
+
+export { ResetOptions }
+
+export { ResultOptions }
+
+export { SetDataOptions }
+
+export { shouldThrowError }
+
+export { SkipToken }
+
+export { skipToken }
+
+declare type SkipTokenForUseQueries = symbol;
+
+declare interface SolidInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryKey' | 'suspense'> {
+    queryKey: TQueryKey;
+    /**
+     * Only applicable while rendering queries on the server with streaming.
+     * Set `deferStream` to `true` to wait for the query to resolve on the server before flushing the stream.
+     * This can be useful to avoid sending a loading state to the client before the query has resolved.
+     * Defaults to `false`.
+     */
+    deferStream?: boolean;
+    /**
+     * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
+     * The `data` property on useInfiniteQuery is a SolidJS resource and will automatically suspend when the data is loading.
+     * Setting `suspense` to `false` will be a no-op.
+     */
+    suspense?: boolean;
+}
+export { SolidInfiniteQueryOptions }
+export { SolidInfiniteQueryOptions as SolidInfiniteQueryOptions_alias_1 }
+
+declare interface SolidMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>, '_defaulted'> {
+}
+export { SolidMutationOptions }
+export { SolidMutationOptions as SolidMutationOptions_alias_1 }
+
+declare interface SolidQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> {
+}
+export { SolidQueryOptions }
+export { SolidQueryOptions as SolidQueryOptions_alias_1 }
+
+export { StaleTime }
+
+export { StaleTimeFunction }
+
+export { ThrowOnError }
+
+export { TimeoutCallback }
+
+export { timeoutManager }
+
+export { TimeoutProvider }
+
+declare type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
+    initialData?: undefined;
+}>;
+export { UndefinedInitialDataInfiniteOptions }
+export { UndefinedInitialDataInfiniteOptions as UndefinedInitialDataInfiniteOptions_alias_1 }
+
+declare type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    initialData?: undefined;
+}>;
+export { UndefinedInitialDataOptions }
+export { UndefinedInitialDataOptions as UndefinedInitialDataOptions_alias_1 }
+
+export { UnsetMarker }
+
+export { unsetMarker }
+
+export { Updater }
+
+declare type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TOnMutateResult>, {
+    mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult>;
+}> & {
+    mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TOnMutateResult>;
+};
+export { UseBaseMutationResult as CreateBaseMutationResult }
+export { UseBaseMutationResult }
+export { UseBaseMutationResult as UseBaseMutationResult_alias_1 }
+
+export declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: Accessor<UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>>, Observer: typeof QueryObserver, queryClient?: Accessor<QueryClient>): QueryObserverResult<TData, TError>;
+
+declare interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'suspense'> {
+    /**
+     * Only applicable while rendering queries on the server with streaming.
+     * Set `deferStream` to `true` to wait for the query to resolve on the server before flushing the stream.
+     * This can be useful to avoid sending a loading state to the client before the query has resolved.
+     * Defaults to `false`.
+     */
+    deferStream?: boolean;
+    /**
+     * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
+     * The `data` property on useQuery is a SolidJS resource and will automatically suspend when the data is loading.
+     * Setting `suspense` to `false` will be a no-op.
+     */
+    suspense?: boolean;
+}
+export { UseBaseQueryOptions as CreateBaseQueryOptions }
+export { UseBaseQueryOptions }
+export { UseBaseQueryOptions as UseBaseQueryOptions_alias_1 }
+
+declare type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
+export { UseBaseQueryResult as CreateBaseQueryResult }
+export { UseBaseQueryResult }
+export { UseBaseQueryResult as UseBaseQueryResult_alias_1 }
+
+declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): DefinedUseInfiniteQueryResult<TData, TError>;
+
+declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): UseInfiniteQueryResult<TData, TError>;
+export { useInfiniteQuery }
+export { useInfiniteQuery as useInfiniteQuery_alias_1 }
+
+declare type UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>;
+export { UseInfiniteQueryOptions as CreateInfiniteQueryOptions }
+export { UseInfiniteQueryOptions }
+export { UseInfiniteQueryOptions as UseInfiniteQueryOptions_alias_1 }
+
+declare type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
+export { UseInfiniteQueryResult as CreateInfiniteQueryResult }
+export { UseInfiniteQueryResult }
+export { UseInfiniteQueryResult as UseInfiniteQueryResult_alias_1 }
+
+declare function useIsFetching(filters?: Accessor<QueryFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
+export { useIsFetching as createIsFetching }
+export { useIsFetching }
+export { useIsFetching as useIsFetching_alias_1 }
+
+declare function useIsMutating(filters?: Accessor<MutationFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
+export { useIsMutating as createIsMutating }
+export { useIsMutating }
+export { useIsMutating as useIsMutating_alias_1 }
+
+declare const useIsRestoring: () => Accessor<boolean>;
+export { useIsRestoring }
+export { useIsRestoring as useIsRestoring_alias_1 }
+
+declare type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutateFunction<TData, TError, TVariables, TOnMutateResult>;
+export { UseMutateAsyncFunction as CreateMutateAsyncFunction }
+export { UseMutateAsyncFunction }
+export { UseMutateAsyncFunction as UseMutateAsyncFunction_alias_1 }
+
+declare type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TOnMutateResult>>) => void;
+export { UseMutateFunction as CreateMutateFunction }
+export { UseMutateFunction }
+export { UseMutateFunction as UseMutateFunction_alias_1 }
+
+declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown>(options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>, queryClient?: Accessor<QueryClient>): UseMutationResult<TData, TError, TVariables, TOnMutateResult>;
+export { useMutation }
+export { useMutation as useMutation_alias_1 }
+
+declare type UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = Accessor<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>>;
+export { UseMutationOptions as CreateMutationOptions }
+export { UseMutationOptions }
+export { UseMutationOptions as UseMutationOptions_alias_1 }
+
+declare type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>;
+export { UseMutationResult as CreateMutationResult }
+export { UseMutationResult }
+export { UseMutationResult as UseMutationResult_alias_1 }
+
+declare function useMutationState<TResult = MutationState>(options?: Accessor<MutationStateOptions<TResult>>, queryClient?: Accessor<QueryClient>): Accessor<Array<TResult>>;
+export { useMutationState as createMutationState }
+export { useMutationState }
+export { useMutationState as useMutationState_alias_1 }
+
+declare function useQueries<T extends Array<any>, TCombinedResult extends QueriesResults<T> = QueriesResults<T>>(queriesOptions: Accessor<{
+    queries: readonly [...QueriesOptions<T>] | readonly [...{
+        [K in keyof T]: GetOptions<T[K]>;
+    }];
+    combine?: (result: QueriesResults<T>) => TCombinedResult;
+}>, queryClient?: Accessor<QueryClient>): TCombinedResult;
+export { useQueries }
+export { useQueries as useQueries_alias_1 }
+
+declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): UseQueryResult<TData, TError>;
+
+declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): DefinedUseQueryResult<TData, TError>;
+export { useQuery }
+export { useQuery as useQuery_alias_1 }
+
+declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
+export { useQueryClient }
+export { useQueryClient as useQueryClient_alias_1 }
+
+declare type UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>>;
+export { UseQueryOptions as CreateQueryOptions }
+export { UseQueryOptions }
+export { UseQueryOptions as UseQueryOptions_alias_1 }
+
+declare type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' | 'suspense'> & {
+    placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
+    /**
+     * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
+     * The `data` property on useQueries is a plain object and not a SolidJS Resource.
+     * It will not suspend when the data is loading.
+     * Setting `suspense` to `true` will be a no-op.
+     */
+    suspense?: boolean;
+};
+
+declare type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
+export { UseQueryResult as CreateQueryResult }
+export { UseQueryResult }
+export { UseQueryResult as UseQueryResult_alias_1 }
+
+export { WithRequired }
+
+export { }

node_modules/@tanstack/solid-query/build/dev.cjs

@@ -0,0 +1,549 @@
+'use strict';
+
+var queryCore = require('@tanstack/query-core');
+var solidJs = require('solid-js');
+var web = require('solid-js/web');
+var store = require('solid-js/store');
+
+// src/useQuery.ts
+exports.QueryClientContext = solidJs.createContext(void 0);
+exports.useQueryClient = (queryClient) => {
+  if (queryClient) {
+    return queryClient;
+  }
+  const client = solidJs.useContext(exports.QueryClientContext);
+  if (!client) {
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  }
+  return client();
+};
+exports.QueryClientProvider = (props) => {
+  solidJs.createRenderEffect((unmount) => {
+    unmount?.();
+    props.client.mount();
+    return props.client.unmount.bind(props.client);
+  });
+  solidJs.onCleanup(() => props.client.unmount());
+  return web.createComponent(exports.QueryClientContext.Provider, {
+    value: () => props.client,
+    get children() {
+      return props.children;
+    }
+  });
+};
+var IsRestoringContext = solidJs.createContext(() => false);
+exports.useIsRestoring = () => solidJs.useContext(IsRestoringContext);
+exports.IsRestoringProvider = IsRestoringContext.Provider;
+
+// src/useBaseQuery.ts
+function reconcileFn(store$1, result, reconcileOption, queryHash) {
+  if (reconcileOption === false) return result;
+  if (typeof reconcileOption === "function") {
+    const newData2 = reconcileOption(store$1.data, result.data);
+    return { ...result, data: newData2 };
+  }
+  let data = result.data;
+  if (store$1.data === void 0) {
+    try {
+      data = structuredClone(data);
+    } catch (error) {
+      {
+        if (error instanceof Error) {
+          console.warn(
+            `Unable to correctly reconcile data for query key: ${queryHash}. Possibly because the query data contains data structures that aren't supported by the 'structuredClone' algorithm. Consider using a callback function instead to manage the reconciliation manually.
+
+ Error Received: ${error.name} - ${error.message}`
+          );
+        }
+      }
+    }
+  }
+  const newData = store.reconcile(data, { key: reconcileOption })(store$1.data);
+  return { ...result, data: newData };
+}
+var hydratableObserverResult = (query, result) => {
+  if (!web.isServer) return result;
+  const obj = {
+    ...store.unwrap(result),
+    // During SSR, functions cannot be serialized, so we need to remove them
+    // This is safe because we will add these functions back when the query is hydrated
+    refetch: void 0
+  };
+  if ("fetchNextPage" in result) {
+    obj.fetchNextPage = void 0;
+    obj.fetchPreviousPage = void 0;
+  }
+  obj.hydrationData = {
+    state: query.state,
+    queryKey: query.queryKey,
+    queryHash: query.queryHash,
+    ...query.meta && { meta: query.meta }
+  };
+  return obj;
+};
+function useBaseQuery(options, Observer, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const isRestoring = exports.useIsRestoring();
+  let unsubscribeQueued = false;
+  const defaultedOptions = solidJs.createMemo(() => {
+    const defaultOptions = client().defaultQueryOptions(options());
+    defaultOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
+    defaultOptions.structuralSharing = false;
+    if (web.isServer) {
+      defaultOptions.retry = false;
+      defaultOptions.throwOnError = true;
+      defaultOptions.experimental_prefetchInRender = true;
+    }
+    return defaultOptions;
+  });
+  const initialOptions = defaultedOptions();
+  const [observer, setObserver] = solidJs.createSignal(
+    new Observer(client(), defaultedOptions())
+  );
+  let observerResult = observer().getOptimisticResult(defaultedOptions());
+  const [state, setState] = store.createStore(observerResult);
+  const createServerSubscriber = (resolve, reject) => {
+    return observer().subscribe((result) => {
+      queryCore.notifyManager.batchCalls(() => {
+        const query = observer().getCurrentQuery();
+        const unwrappedResult = hydratableObserverResult(query, result);
+        if (result.data !== void 0 && unwrappedResult.isError) {
+          reject(unwrappedResult.error);
+          unsubscribeIfQueued();
+        } else {
+          resolve(unwrappedResult);
+          unsubscribeIfQueued();
+        }
+      })();
+    });
+  };
+  const unsubscribeIfQueued = () => {
+    if (unsubscribeQueued) {
+      unsubscribe?.();
+      unsubscribeQueued = false;
+    }
+  };
+  const createClientSubscriber = () => {
+    const obs = observer();
+    return obs.subscribe((result) => {
+      observerResult = result;
+      queueMicrotask(() => {
+        if (unsubscribe) {
+          refetch();
+        }
+      });
+    });
+  };
+  function setStateWithReconciliation(res) {
+    const opts = observer().options;
+    const reconcileOptions = opts.reconcile;
+    setState((store) => {
+      return reconcileFn(
+        store,
+        res,
+        reconcileOptions === void 0 ? false : reconcileOptions,
+        opts.queryHash
+      );
+    });
+  }
+  function createDeepSignal() {
+    return [
+      () => state,
+      (v) => {
+        const unwrapped = store.unwrap(state);
+        if (typeof v === "function") {
+          v = v(unwrapped);
+        }
+        if (v?.hydrationData) {
+          const { hydrationData, ...rest } = v;
+          v = rest;
+        }
+        setStateWithReconciliation(v);
+      }
+    ];
+  }
+  let unsubscribe = null;
+  let resolver = null;
+  const [queryResource, { refetch }] = solidJs.createResource(
+    () => {
+      const obs = observer();
+      return new Promise((resolve, reject) => {
+        resolver = resolve;
+        if (web.isServer) {
+          unsubscribe = createServerSubscriber(resolve, reject);
+        } else if (!unsubscribe && !isRestoring()) {
+          unsubscribe = createClientSubscriber();
+        }
+        obs.updateResult();
+        if (observerResult.isError && !observerResult.isFetching && !isRestoring() && queryCore.shouldThrowError(obs.options.throwOnError, [
+          observerResult.error,
+          obs.getCurrentQuery()
+        ])) {
+          setStateWithReconciliation(observerResult);
+          return reject(observerResult.error);
+        }
+        if (!observerResult.isLoading) {
+          resolver = null;
+          return resolve(
+            hydratableObserverResult(obs.getCurrentQuery(), observerResult)
+          );
+        }
+        setStateWithReconciliation(observerResult);
+      });
+    },
+    {
+      storage: createDeepSignal,
+      get deferStream() {
+        return options().deferStream;
+      },
+      /**
+       * If this resource was populated on the server (either sync render, or streamed in over time), onHydrated
+       * will be called. This is the point at which we can hydrate the query cache state, and setup the query subscriber.
+       *
+       * Leveraging onHydrated allows us to plug into the async and streaming support that solidjs resources already support.
+       *
+       * Note that this is only invoked on the client, for queries that were originally run on the server.
+       */
+      onHydrated(_k, info) {
+        if (info.value && "hydrationData" in info.value) {
+          queryCore.hydrate(client(), {
+            // @ts-expect-error - hydrationData is not correctly typed internally
+            queries: [{ ...info.value.hydrationData }]
+          });
+        }
+        if (unsubscribe) return;
+        const newOptions = { ...initialOptions };
+        if ((initialOptions.staleTime || !initialOptions.initialData) && info.value) {
+          newOptions.refetchOnMount = false;
+        }
+        observer().setOptions(newOptions);
+        setStateWithReconciliation(observer().getOptimisticResult(newOptions));
+        unsubscribe = createClientSubscriber();
+      }
+    }
+  );
+  solidJs.createComputed(
+    solidJs.on(
+      client,
+      (c) => {
+        if (unsubscribe) {
+          unsubscribe();
+        }
+        const newObserver = new Observer(c, defaultedOptions());
+        unsubscribe = createClientSubscriber();
+        setObserver(newObserver);
+      },
+      {
+        defer: true
+      }
+    )
+  );
+  solidJs.createComputed(
+    solidJs.on(
+      isRestoring,
+      (restoring) => {
+        if (!restoring && !web.isServer) {
+          refetch();
+        }
+      },
+      { defer: true }
+    )
+  );
+  solidJs.onCleanup(() => {
+    if (web.isServer && queryResource.loading) {
+      unsubscribeQueued = true;
+      return;
+    }
+    if (unsubscribe) {
+      unsubscribe();
+      unsubscribe = null;
+    }
+    if (resolver && !web.isServer) {
+      resolver(observerResult);
+      resolver = null;
+    }
+  });
+  solidJs.createComputed(
+    solidJs.on(
+      [observer, defaultedOptions],
+      ([obs, opts]) => {
+        obs.setOptions(opts);
+        setStateWithReconciliation(obs.getOptimisticResult(opts));
+        refetch();
+      },
+      { defer: true }
+    )
+  );
+  const handler = {
+    get(target, prop) {
+      if (prop === "data") {
+        if (state.data !== void 0) {
+          return queryResource.latest?.data;
+        }
+        return queryResource()?.data;
+      }
+      return Reflect.get(target, prop);
+    }
+  };
+  return new Proxy(state, handler);
+}
+
+// src/useQuery.ts
+function useQuery(options, queryClient) {
+  return useBaseQuery(
+    solidJs.createMemo(() => options()),
+    queryCore.QueryObserver,
+    queryClient
+  );
+}
+function useInfiniteQuery(options, queryClient) {
+  return useBaseQuery(
+    solidJs.createMemo(() => options()),
+    queryCore.InfiniteQueryObserver,
+    queryClient
+  );
+}
+function useMutation(options, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const observer = new queryCore.MutationObserver(client(), options());
+  const mutate = (variables, mutateOptions) => {
+    observer.mutate(variables, mutateOptions).catch(queryCore.noop);
+  };
+  const [state, setState] = store.createStore({
+    ...observer.getCurrentResult(),
+    mutate,
+    mutateAsync: observer.getCurrentResult().mutate
+  });
+  solidJs.createComputed(() => {
+    observer.setOptions(options());
+  });
+  solidJs.createComputed(
+    solidJs.on(
+      () => state.status,
+      () => {
+        if (state.isError && queryCore.shouldThrowError(observer.options.throwOnError, [state.error])) {
+          throw state.error;
+        }
+      }
+    )
+  );
+  const unsubscribe = observer.subscribe((result) => {
+    setState({
+      ...result,
+      mutate,
+      mutateAsync: result.mutate
+    });
+  });
+  solidJs.onCleanup(unsubscribe);
+  return state;
+}
+function useQueries(queriesOptions, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const isRestoring = exports.useIsRestoring();
+  const defaultedQueries = solidJs.createMemo(
+    () => queriesOptions().queries.map(
+      (options) => solidJs.mergeProps(
+        client().defaultQueryOptions(options),
+        {
+          get _optimisticResults() {
+            return isRestoring() ? "isRestoring" : "optimistic";
+          }
+        }
+      )
+    )
+  );
+  const observer = new queryCore.QueriesObserver(
+    client(),
+    defaultedQueries(),
+    queriesOptions().combine ? {
+      combine: queriesOptions().combine
+    } : void 0
+  );
+  const [state, setState] = store.createStore(
+    observer.getOptimisticResult(
+      defaultedQueries(),
+      queriesOptions().combine
+    )[1]()
+  );
+  solidJs.createRenderEffect(
+    solidJs.on(
+      () => queriesOptions().queries.length,
+      () => setState(
+        observer.getOptimisticResult(
+          defaultedQueries(),
+          queriesOptions().combine
+        )[1]()
+      )
+    )
+  );
+  const dataResources = solidJs.createMemo(
+    solidJs.on(
+      () => state.length,
+      () => state.map((queryRes) => {
+        const dataPromise = () => new Promise((resolve) => {
+          if (queryRes.isFetching && queryRes.isLoading) return;
+          resolve(store.unwrap(queryRes.data));
+        });
+        return solidJs.createResource(dataPromise);
+      })
+    )
+  );
+  solidJs.batch(() => {
+    const dataResources_ = dataResources();
+    for (let index = 0; index < dataResources_.length; index++) {
+      const dataResource = dataResources_[index];
+      dataResource[1].mutate(() => store.unwrap(state[index].data));
+      dataResource[1].refetch();
+    }
+  });
+  let taskQueue = [];
+  const subscribeToObserver = () => observer.subscribe((result) => {
+    taskQueue.push(() => {
+      solidJs.batch(() => {
+        const dataResources_ = dataResources();
+        for (let index = 0; index < dataResources_.length; index++) {
+          const dataResource = dataResources_[index];
+          const unwrappedResult = { ...store.unwrap(result[index]) };
+          setState(index, store.unwrap(unwrappedResult));
+          dataResource[1].mutate(() => store.unwrap(state[index].data));
+          dataResource[1].refetch();
+        }
+      });
+    });
+    queueMicrotask(() => {
+      const taskToRun = taskQueue.pop();
+      if (taskToRun) taskToRun();
+      taskQueue = [];
+    });
+  });
+  let unsubscribe = queryCore.noop;
+  solidJs.createComputed((cleanup) => {
+    cleanup?.();
+    unsubscribe = isRestoring() ? queryCore.noop : subscribeToObserver();
+    return () => queueMicrotask(unsubscribe);
+  });
+  solidJs.onCleanup(unsubscribe);
+  solidJs.onMount(() => {
+    observer.setQueries(
+      defaultedQueries(),
+      queriesOptions().combine ? {
+        combine: queriesOptions().combine
+      } : void 0
+    );
+  });
+  solidJs.createComputed(() => {
+    observer.setQueries(
+      defaultedQueries(),
+      queriesOptions().combine ? {
+        combine: queriesOptions().combine
+      } : void 0
+    );
+  });
+  const handler = (index) => ({
+    get(target, prop) {
+      if (prop === "data") {
+        return dataResources()[index][0]();
+      }
+      return Reflect.get(target, prop);
+    }
+  });
+  const getProxies = () => state.map((s, index) => {
+    return new Proxy(s, handler(index));
+  });
+  const [proxyState, setProxyState] = store.createStore(getProxies());
+  solidJs.createRenderEffect(() => setProxyState(getProxies()));
+  return proxyState;
+}
+exports.QueryClient = class QueryClient extends queryCore.QueryClient {
+  constructor(config = {}) {
+    super(config);
+  }
+};
+
+// src/queryOptions.ts
+function queryOptions(options) {
+  return options;
+}
+function useIsFetching(filters, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const queryCache = solidJs.createMemo(() => client().getQueryCache());
+  const [fetches, setFetches] = solidJs.createSignal(client().isFetching(filters?.()));
+  const unsubscribe = queryCache().subscribe(() => {
+    setFetches(client().isFetching(filters?.()));
+  });
+  solidJs.onCleanup(unsubscribe);
+  return fetches;
+}
+
+// src/infiniteQueryOptions.ts
+function infiniteQueryOptions(options) {
+  return options;
+}
+
+// src/mutationOptions.ts
+function mutationOptions(options) {
+  return options;
+}
+function useIsMutating(filters, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const mutationCache = solidJs.createMemo(() => client().getMutationCache());
+  const [mutations, setMutations] = solidJs.createSignal(
+    client().isMutating(filters?.())
+  );
+  const unsubscribe = mutationCache().subscribe((_result) => {
+    setMutations(client().isMutating(filters?.()));
+  });
+  solidJs.onCleanup(unsubscribe);
+  return mutations;
+}
+function getResult(mutationCache, options) {
+  return mutationCache.findAll(options.filters).map(
+    (mutation) => options.select ? options.select(mutation) : mutation.state
+  );
+}
+function useMutationState(options = () => ({}), queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const mutationCache = solidJs.createMemo(() => client().getMutationCache());
+  const [result, setResult] = solidJs.createSignal(
+    getResult(mutationCache(), options())
+  );
+  solidJs.createEffect(() => {
+    const unsubscribe = mutationCache().subscribe(() => {
+      const nextResult = queryCore.replaceEqualDeep(
+        result(),
+        getResult(mutationCache(), options())
+      );
+      if (result() !== nextResult) {
+        setResult(nextResult);
+      }
+    });
+    solidJs.onCleanup(unsubscribe);
+  });
+  return result;
+}
+
+// src/index.ts
+exports.createQuery = useQuery;
+exports.createInfiniteQuery = useInfiniteQuery;
+exports.createMutation = useMutation;
+exports.createQueries = useQueries;
+
+exports.createIsFetching = useIsFetching;
+exports.createIsMutating = useIsMutating;
+exports.createMutationState = useMutationState;
+exports.infiniteQueryOptions = infiniteQueryOptions;
+exports.mutationOptions = mutationOptions;
+exports.queryOptions = queryOptions;
+exports.useInfiniteQuery = useInfiniteQuery;
+exports.useIsFetching = useIsFetching;
+exports.useIsMutating = useIsMutating;
+exports.useMutation = useMutation;
+exports.useMutationState = useMutationState;
+exports.useQueries = useQueries;
+exports.useQuery = useQuery;
+Object.keys(queryCore).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return queryCore[k]; }
+  });
+});

node_modules/@tanstack/solid-query/build/dev.d.cts

@@ -0,0 +1,200 @@
+export { DefinedUseBaseQueryResult } from './_tsup-dts-rollup.cjs';
+export { DefinedUseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
+export { DefinedUseQueryResult } from './_tsup-dts-rollup.cjs';
+export { SolidInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
+export { SolidMutationOptions } from './_tsup-dts-rollup.cjs';
+export { SolidQueryOptions } from './_tsup-dts-rollup.cjs';
+export { UseBaseMutationResult } from './_tsup-dts-rollup.cjs';
+export { UseBaseQueryOptions } from './_tsup-dts-rollup.cjs';
+export { UseBaseQueryResult } from './_tsup-dts-rollup.cjs';
+export { UseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
+export { UseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
+export { UseMutateAsyncFunction } from './_tsup-dts-rollup.cjs';
+export { UseMutateFunction } from './_tsup-dts-rollup.cjs';
+export { UseMutationOptions } from './_tsup-dts-rollup.cjs';
+export { UseMutationResult } from './_tsup-dts-rollup.cjs';
+export { UseQueryOptions } from './_tsup-dts-rollup.cjs';
+export { UseQueryResult } from './_tsup-dts-rollup.cjs';
+export { CreateBaseQueryOptions } from './_tsup-dts-rollup.cjs';
+export { CreateBaseQueryResult } from './_tsup-dts-rollup.cjs';
+export { CreateInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
+export { CreateInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
+export { CreateMutateAsyncFunction } from './_tsup-dts-rollup.cjs';
+export { CreateMutateFunction } from './_tsup-dts-rollup.cjs';
+export { CreateMutationOptions } from './_tsup-dts-rollup.cjs';
+export { CreateMutationResult } from './_tsup-dts-rollup.cjs';
+export { CreateBaseMutationResult } from './_tsup-dts-rollup.cjs';
+export { CreateQueryOptions } from './_tsup-dts-rollup.cjs';
+export { CreateQueryResult } from './_tsup-dts-rollup.cjs';
+export { DefinedCreateBaseQueryResult } from './_tsup-dts-rollup.cjs';
+export { DefinedCreateInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
+export { DefinedCreateQueryResult } from './_tsup-dts-rollup.cjs';
+export { QueryClient_alias_1 as QueryClient } from './_tsup-dts-rollup.cjs';
+export { QueryObserverOptions_alias_1 as QueryObserverOptions } from './_tsup-dts-rollup.cjs';
+export { DefaultOptions_alias_1 as DefaultOptions } from './_tsup-dts-rollup.cjs';
+export { QueryClientConfig_alias_1 as QueryClientConfig } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserverOptions_alias_1 as InfiniteQueryObserverOptions } from './_tsup-dts-rollup.cjs';
+export { useQuery } from './_tsup-dts-rollup.cjs';
+export { createQuery } from './_tsup-dts-rollup.cjs';
+export { queryOptions } from './_tsup-dts-rollup.cjs';
+export { DefinedInitialDataOptions } from './_tsup-dts-rollup.cjs';
+export { UndefinedInitialDataOptions } from './_tsup-dts-rollup.cjs';
+export { QueryClientContext_alias_1 as QueryClientContext } from './_tsup-dts-rollup.cjs';
+export { QueryClientProvider_alias_1 as QueryClientProvider } from './_tsup-dts-rollup.cjs';
+export { useQueryClient_alias_1 as useQueryClient } from './_tsup-dts-rollup.cjs';
+export { QueryClientProviderProps_alias_1 as QueryClientProviderProps } from './_tsup-dts-rollup.cjs';
+export { useIsFetching } from './_tsup-dts-rollup.cjs';
+export { createIsFetching } from './_tsup-dts-rollup.cjs';
+export { useInfiniteQuery } from './_tsup-dts-rollup.cjs';
+export { createInfiniteQuery } from './_tsup-dts-rollup.cjs';
+export { infiniteQueryOptions } from './_tsup-dts-rollup.cjs';
+export { DefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.cjs';
+export { UndefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.cjs';
+export { useMutation } from './_tsup-dts-rollup.cjs';
+export { mutationOptions } from './_tsup-dts-rollup.cjs';
+export { createMutation } from './_tsup-dts-rollup.cjs';
+export { useIsMutating } from './_tsup-dts-rollup.cjs';
+export { createIsMutating } from './_tsup-dts-rollup.cjs';
+export { useMutationState } from './_tsup-dts-rollup.cjs';
+export { createMutationState } from './_tsup-dts-rollup.cjs';
+export { useQueries } from './_tsup-dts-rollup.cjs';
+export { createQueries } from './_tsup-dts-rollup.cjs';
+export { useIsRestoring } from './_tsup-dts-rollup.cjs';
+export { IsRestoringProvider } from './_tsup-dts-rollup.cjs';
+export { focusManager } from './_tsup-dts-rollup.cjs';
+export { environmentManager } from './_tsup-dts-rollup.cjs';
+export { defaultShouldDehydrateMutation } from './_tsup-dts-rollup.cjs';
+export { defaultShouldDehydrateQuery } from './_tsup-dts-rollup.cjs';
+export { dehydrate } from './_tsup-dts-rollup.cjs';
+export { hydrate } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserver } from './_tsup-dts-rollup.cjs';
+export { MutationCache } from './_tsup-dts-rollup.cjs';
+export { MutationCacheNotifyEvent } from './_tsup-dts-rollup.cjs';
+export { MutationObserver } from './_tsup-dts-rollup.cjs';
+export { defaultScheduler } from './_tsup-dts-rollup.cjs';
+export { notifyManager } from './_tsup-dts-rollup.cjs';
+export { onlineManager } from './_tsup-dts-rollup.cjs';
+export { QueriesObserver } from './_tsup-dts-rollup.cjs';
+export { QueryCache } from './_tsup-dts-rollup.cjs';
+export { QueryCacheNotifyEvent } from './_tsup-dts-rollup.cjs';
+export { QueryObserver } from './_tsup-dts-rollup.cjs';
+export { CancelledError } from './_tsup-dts-rollup.cjs';
+export { isCancelledError } from './_tsup-dts-rollup.cjs';
+export { timeoutManager } from './_tsup-dts-rollup.cjs';
+export { ManagedTimerId } from './_tsup-dts-rollup.cjs';
+export { TimeoutCallback } from './_tsup-dts-rollup.cjs';
+export { TimeoutProvider } from './_tsup-dts-rollup.cjs';
+export { hashKey } from './_tsup-dts-rollup.cjs';
+export { isServer } from './_tsup-dts-rollup.cjs';
+export { keepPreviousData } from './_tsup-dts-rollup.cjs';
+export { matchMutation } from './_tsup-dts-rollup.cjs';
+export { matchQuery } from './_tsup-dts-rollup.cjs';
+export { noop } from './_tsup-dts-rollup.cjs';
+export { partialMatchKey } from './_tsup-dts-rollup.cjs';
+export { replaceEqualDeep } from './_tsup-dts-rollup.cjs';
+export { shouldThrowError } from './_tsup-dts-rollup.cjs';
+export { skipToken } from './_tsup-dts-rollup.cjs';
+export { MutationFilters } from './_tsup-dts-rollup.cjs';
+export { QueryFilters } from './_tsup-dts-rollup.cjs';
+export { SkipToken } from './_tsup-dts-rollup.cjs';
+export { Updater } from './_tsup-dts-rollup.cjs';
+export { experimental_streamedQuery } from './_tsup-dts-rollup.cjs';
+export { DehydratedState } from './_tsup-dts-rollup.cjs';
+export { DehydrateOptions } from './_tsup-dts-rollup.cjs';
+export { HydrateOptions } from './_tsup-dts-rollup.cjs';
+export { Mutation } from './_tsup-dts-rollup.cjs';
+export { MutationState } from './_tsup-dts-rollup.cjs';
+export { QueriesObserverOptions } from './_tsup-dts-rollup.cjs';
+export { Query } from './_tsup-dts-rollup.cjs';
+export { QueryState } from './_tsup-dts-rollup.cjs';
+export { NonUndefinedGuard } from './_tsup-dts-rollup.cjs';
+export { DistributiveOmit } from './_tsup-dts-rollup.cjs';
+export { OmitKeyof } from './_tsup-dts-rollup.cjs';
+export { Override } from './_tsup-dts-rollup.cjs';
+export { NoInfer } from './_tsup-dts-rollup.cjs';
+export { Register } from './_tsup-dts-rollup.cjs';
+export { DefaultError } from './_tsup-dts-rollup.cjs';
+export { QueryKey } from './_tsup-dts-rollup.cjs';
+export { dataTagSymbol } from './_tsup-dts-rollup.cjs';
+export { dataTagErrorSymbol } from './_tsup-dts-rollup.cjs';
+export { unsetMarker } from './_tsup-dts-rollup.cjs';
+export { UnsetMarker } from './_tsup-dts-rollup.cjs';
+export { AnyDataTag } from './_tsup-dts-rollup.cjs';
+export { DataTag } from './_tsup-dts-rollup.cjs';
+export { InferDataFromTag } from './_tsup-dts-rollup.cjs';
+export { InferErrorFromTag } from './_tsup-dts-rollup.cjs';
+export { QueryFunction } from './_tsup-dts-rollup.cjs';
+export { StaleTime } from './_tsup-dts-rollup.cjs';
+export { StaleTimeFunction } from './_tsup-dts-rollup.cjs';
+export { QueryBooleanOption } from './_tsup-dts-rollup.cjs';
+export { QueryPersister } from './_tsup-dts-rollup.cjs';
+export { QueryFunctionContext } from './_tsup-dts-rollup.cjs';
+export { InitialDataFunction } from './_tsup-dts-rollup.cjs';
+export { PlaceholderDataFunction } from './_tsup-dts-rollup.cjs';
+export { QueriesPlaceholderDataFunction } from './_tsup-dts-rollup.cjs';
+export { QueryKeyHashFunction } from './_tsup-dts-rollup.cjs';
+export { GetPreviousPageParamFunction } from './_tsup-dts-rollup.cjs';
+export { GetNextPageParamFunction } from './_tsup-dts-rollup.cjs';
+export { InfiniteData } from './_tsup-dts-rollup.cjs';
+export { QueryMeta } from './_tsup-dts-rollup.cjs';
+export { NetworkMode } from './_tsup-dts-rollup.cjs';
+export { NotifyOnChangeProps } from './_tsup-dts-rollup.cjs';
+export { QueryOptions } from './_tsup-dts-rollup.cjs';
+export { InitialPageParam } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryPageParamsOptions } from './_tsup-dts-rollup.cjs';
+export { ThrowOnError } from './_tsup-dts-rollup.cjs';
+export { WithRequired } from './_tsup-dts-rollup.cjs';
+export { DefaultedQueryObserverOptions } from './_tsup-dts-rollup.cjs';
+export { DefaultedInfiniteQueryObserverOptions } from './_tsup-dts-rollup.cjs';
+export { FetchQueryOptions } from './_tsup-dts-rollup.cjs';
+export { EnsureQueryDataOptions } from './_tsup-dts-rollup.cjs';
+export { EnsureInfiniteQueryDataOptions } from './_tsup-dts-rollup.cjs';
+export { FetchInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
+export { ResultOptions } from './_tsup-dts-rollup.cjs';
+export { RefetchOptions } from './_tsup-dts-rollup.cjs';
+export { InvalidateQueryFilters } from './_tsup-dts-rollup.cjs';
+export { RefetchQueryFilters } from './_tsup-dts-rollup.cjs';
+export { InvalidateOptions } from './_tsup-dts-rollup.cjs';
+export { ResetOptions } from './_tsup-dts-rollup.cjs';
+export { FetchNextPageOptions } from './_tsup-dts-rollup.cjs';
+export { FetchPreviousPageOptions } from './_tsup-dts-rollup.cjs';
+export { QueryStatus } from './_tsup-dts-rollup.cjs';
+export { FetchStatus } from './_tsup-dts-rollup.cjs';
+export { QueryObserverBaseResult } from './_tsup-dts-rollup.cjs';
+export { QueryObserverPendingResult } from './_tsup-dts-rollup.cjs';
+export { QueryObserverLoadingResult } from './_tsup-dts-rollup.cjs';
+export { QueryObserverLoadingErrorResult } from './_tsup-dts-rollup.cjs';
+export { QueryObserverRefetchErrorResult } from './_tsup-dts-rollup.cjs';
+export { QueryObserverSuccessResult } from './_tsup-dts-rollup.cjs';
+export { QueryObserverPlaceholderResult } from './_tsup-dts-rollup.cjs';
+export { DefinedQueryObserverResult } from './_tsup-dts-rollup.cjs';
+export { QueryObserverResult } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserverBaseResult } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserverPendingResult } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserverLoadingResult } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserverLoadingErrorResult } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserverRefetchErrorResult } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserverSuccessResult } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserverPlaceholderResult } from './_tsup-dts-rollup.cjs';
+export { DefinedInfiniteQueryObserverResult } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserverResult } from './_tsup-dts-rollup.cjs';
+export { MutationKey } from './_tsup-dts-rollup.cjs';
+export { MutationStatus } from './_tsup-dts-rollup.cjs';
+export { MutationScope } from './_tsup-dts-rollup.cjs';
+export { MutationMeta } from './_tsup-dts-rollup.cjs';
+export { MutationFunctionContext } from './_tsup-dts-rollup.cjs';
+export { MutationFunction } from './_tsup-dts-rollup.cjs';
+export { MutationOptions } from './_tsup-dts-rollup.cjs';
+export { MutationObserverOptions } from './_tsup-dts-rollup.cjs';
+export { MutateOptions } from './_tsup-dts-rollup.cjs';
+export { MutateFunction } from './_tsup-dts-rollup.cjs';
+export { MutationObserverBaseResult } from './_tsup-dts-rollup.cjs';
+export { MutationObserverIdleResult } from './_tsup-dts-rollup.cjs';
+export { MutationObserverLoadingResult } from './_tsup-dts-rollup.cjs';
+export { MutationObserverErrorResult } from './_tsup-dts-rollup.cjs';
+export { MutationObserverSuccessResult } from './_tsup-dts-rollup.cjs';
+export { MutationObserverResult } from './_tsup-dts-rollup.cjs';
+export { CancelOptions } from './_tsup-dts-rollup.cjs';
+export { SetDataOptions } from './_tsup-dts-rollup.cjs';
+export { NotifyEventType } from './_tsup-dts-rollup.cjs';
+export { NotifyEvent } from './_tsup-dts-rollup.cjs';

node_modules/@tanstack/solid-query/build/dev.d.ts

@@ -0,0 +1,200 @@
+export { DefinedUseBaseQueryResult } from './_tsup-dts-rollup.js';
+export { DefinedUseInfiniteQueryResult } from './_tsup-dts-rollup.js';
+export { DefinedUseQueryResult } from './_tsup-dts-rollup.js';
+export { SolidInfiniteQueryOptions } from './_tsup-dts-rollup.js';
+export { SolidMutationOptions } from './_tsup-dts-rollup.js';
+export { SolidQueryOptions } from './_tsup-dts-rollup.js';
+export { UseBaseMutationResult } from './_tsup-dts-rollup.js';
+export { UseBaseQueryOptions } from './_tsup-dts-rollup.js';
+export { UseBaseQueryResult } from './_tsup-dts-rollup.js';
+export { UseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
+export { UseInfiniteQueryResult } from './_tsup-dts-rollup.js';
+export { UseMutateAsyncFunction } from './_tsup-dts-rollup.js';
+export { UseMutateFunction } from './_tsup-dts-rollup.js';
+export { UseMutationOptions } from './_tsup-dts-rollup.js';
+export { UseMutationResult } from './_tsup-dts-rollup.js';
+export { UseQueryOptions } from './_tsup-dts-rollup.js';
+export { UseQueryResult } from './_tsup-dts-rollup.js';
+export { CreateBaseQueryOptions } from './_tsup-dts-rollup.js';
+export { CreateBaseQueryResult } from './_tsup-dts-rollup.js';
+export { CreateInfiniteQueryOptions } from './_tsup-dts-rollup.js';
+export { CreateInfiniteQueryResult } from './_tsup-dts-rollup.js';
+export { CreateMutateAsyncFunction } from './_tsup-dts-rollup.js';
+export { CreateMutateFunction } from './_tsup-dts-rollup.js';
+export { CreateMutationOptions } from './_tsup-dts-rollup.js';
+export { CreateMutationResult } from './_tsup-dts-rollup.js';
+export { CreateBaseMutationResult } from './_tsup-dts-rollup.js';
+export { CreateQueryOptions } from './_tsup-dts-rollup.js';
+export { CreateQueryResult } from './_tsup-dts-rollup.js';
+export { DefinedCreateBaseQueryResult } from './_tsup-dts-rollup.js';
+export { DefinedCreateInfiniteQueryResult } from './_tsup-dts-rollup.js';
+export { DefinedCreateQueryResult } from './_tsup-dts-rollup.js';
+export { QueryClient_alias_1 as QueryClient } from './_tsup-dts-rollup.js';
+export { QueryObserverOptions_alias_1 as QueryObserverOptions } from './_tsup-dts-rollup.js';
+export { DefaultOptions_alias_1 as DefaultOptions } from './_tsup-dts-rollup.js';
+export { QueryClientConfig_alias_1 as QueryClientConfig } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserverOptions_alias_1 as InfiniteQueryObserverOptions } from './_tsup-dts-rollup.js';
+export { useQuery } from './_tsup-dts-rollup.js';
+export { createQuery } from './_tsup-dts-rollup.js';
+export { queryOptions } from './_tsup-dts-rollup.js';
+export { DefinedInitialDataOptions } from './_tsup-dts-rollup.js';
+export { UndefinedInitialDataOptions } from './_tsup-dts-rollup.js';
+export { QueryClientContext_alias_1 as QueryClientContext } from './_tsup-dts-rollup.js';
+export { QueryClientProvider_alias_1 as QueryClientProvider } from './_tsup-dts-rollup.js';
+export { useQueryClient_alias_1 as useQueryClient } from './_tsup-dts-rollup.js';
+export { QueryClientProviderProps_alias_1 as QueryClientProviderProps } from './_tsup-dts-rollup.js';
+export { useIsFetching } from './_tsup-dts-rollup.js';
+export { createIsFetching } from './_tsup-dts-rollup.js';
+export { useInfiniteQuery } from './_tsup-dts-rollup.js';
+export { createInfiniteQuery } from './_tsup-dts-rollup.js';
+export { infiniteQueryOptions } from './_tsup-dts-rollup.js';
+export { DefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.js';
+export { UndefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.js';
+export { useMutation } from './_tsup-dts-rollup.js';
+export { mutationOptions } from './_tsup-dts-rollup.js';
+export { createMutation } from './_tsup-dts-rollup.js';
+export { useIsMutating } from './_tsup-dts-rollup.js';
+export { createIsMutating } from './_tsup-dts-rollup.js';
+export { useMutationState } from './_tsup-dts-rollup.js';
+export { createMutationState } from './_tsup-dts-rollup.js';
+export { useQueries } from './_tsup-dts-rollup.js';
+export { createQueries } from './_tsup-dts-rollup.js';
+export { useIsRestoring } from './_tsup-dts-rollup.js';
+export { IsRestoringProvider } from './_tsup-dts-rollup.js';
+export { focusManager } from './_tsup-dts-rollup.js';
+export { environmentManager } from './_tsup-dts-rollup.js';
+export { defaultShouldDehydrateMutation } from './_tsup-dts-rollup.js';
+export { defaultShouldDehydrateQuery } from './_tsup-dts-rollup.js';
+export { dehydrate } from './_tsup-dts-rollup.js';
+export { hydrate } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserver } from './_tsup-dts-rollup.js';
+export { MutationCache } from './_tsup-dts-rollup.js';
+export { MutationCacheNotifyEvent } from './_tsup-dts-rollup.js';
+export { MutationObserver } from './_tsup-dts-rollup.js';
+export { defaultScheduler } from './_tsup-dts-rollup.js';
+export { notifyManager } from './_tsup-dts-rollup.js';
+export { onlineManager } from './_tsup-dts-rollup.js';
+export { QueriesObserver } from './_tsup-dts-rollup.js';
+export { QueryCache } from './_tsup-dts-rollup.js';
+export { QueryCacheNotifyEvent } from './_tsup-dts-rollup.js';
+export { QueryObserver } from './_tsup-dts-rollup.js';
+export { CancelledError } from './_tsup-dts-rollup.js';
+export { isCancelledError } from './_tsup-dts-rollup.js';
+export { timeoutManager } from './_tsup-dts-rollup.js';
+export { ManagedTimerId } from './_tsup-dts-rollup.js';
+export { TimeoutCallback } from './_tsup-dts-rollup.js';
+export { TimeoutProvider } from './_tsup-dts-rollup.js';
+export { hashKey } from './_tsup-dts-rollup.js';
+export { isServer } from './_tsup-dts-rollup.js';
+export { keepPreviousData } from './_tsup-dts-rollup.js';
+export { matchMutation } from './_tsup-dts-rollup.js';
+export { matchQuery } from './_tsup-dts-rollup.js';
+export { noop } from './_tsup-dts-rollup.js';
+export { partialMatchKey } from './_tsup-dts-rollup.js';
+export { replaceEqualDeep } from './_tsup-dts-rollup.js';
+export { shouldThrowError } from './_tsup-dts-rollup.js';
+export { skipToken } from './_tsup-dts-rollup.js';
+export { MutationFilters } from './_tsup-dts-rollup.js';
+export { QueryFilters } from './_tsup-dts-rollup.js';
+export { SkipToken } from './_tsup-dts-rollup.js';
+export { Updater } from './_tsup-dts-rollup.js';
+export { experimental_streamedQuery } from './_tsup-dts-rollup.js';
+export { DehydratedState } from './_tsup-dts-rollup.js';
+export { DehydrateOptions } from './_tsup-dts-rollup.js';
+export { HydrateOptions } from './_tsup-dts-rollup.js';
+export { Mutation } from './_tsup-dts-rollup.js';
+export { MutationState } from './_tsup-dts-rollup.js';
+export { QueriesObserverOptions } from './_tsup-dts-rollup.js';
+export { Query } from './_tsup-dts-rollup.js';
+export { QueryState } from './_tsup-dts-rollup.js';
+export { NonUndefinedGuard } from './_tsup-dts-rollup.js';
+export { DistributiveOmit } from './_tsup-dts-rollup.js';
+export { OmitKeyof } from './_tsup-dts-rollup.js';
+export { Override } from './_tsup-dts-rollup.js';
+export { NoInfer } from './_tsup-dts-rollup.js';
+export { Register } from './_tsup-dts-rollup.js';
+export { DefaultError } from './_tsup-dts-rollup.js';
+export { QueryKey } from './_tsup-dts-rollup.js';
+export { dataTagSymbol } from './_tsup-dts-rollup.js';
+export { dataTagErrorSymbol } from './_tsup-dts-rollup.js';
+export { unsetMarker } from './_tsup-dts-rollup.js';
+export { UnsetMarker } from './_tsup-dts-rollup.js';
+export { AnyDataTag } from './_tsup-dts-rollup.js';
+export { DataTag } from './_tsup-dts-rollup.js';
+export { InferDataFromTag } from './_tsup-dts-rollup.js';
+export { InferErrorFromTag } from './_tsup-dts-rollup.js';
+export { QueryFunction } from './_tsup-dts-rollup.js';
+export { StaleTime } from './_tsup-dts-rollup.js';
+export { StaleTimeFunction } from './_tsup-dts-rollup.js';
+export { QueryBooleanOption } from './_tsup-dts-rollup.js';
+export { QueryPersister } from './_tsup-dts-rollup.js';
+export { QueryFunctionContext } from './_tsup-dts-rollup.js';
+export { InitialDataFunction } from './_tsup-dts-rollup.js';
+export { PlaceholderDataFunction } from './_tsup-dts-rollup.js';
+export { QueriesPlaceholderDataFunction } from './_tsup-dts-rollup.js';
+export { QueryKeyHashFunction } from './_tsup-dts-rollup.js';
+export { GetPreviousPageParamFunction } from './_tsup-dts-rollup.js';
+export { GetNextPageParamFunction } from './_tsup-dts-rollup.js';
+export { InfiniteData } from './_tsup-dts-rollup.js';
+export { QueryMeta } from './_tsup-dts-rollup.js';
+export { NetworkMode } from './_tsup-dts-rollup.js';
+export { NotifyOnChangeProps } from './_tsup-dts-rollup.js';
+export { QueryOptions } from './_tsup-dts-rollup.js';
+export { InitialPageParam } from './_tsup-dts-rollup.js';
+export { InfiniteQueryPageParamsOptions } from './_tsup-dts-rollup.js';
+export { ThrowOnError } from './_tsup-dts-rollup.js';
+export { WithRequired } from './_tsup-dts-rollup.js';
+export { DefaultedQueryObserverOptions } from './_tsup-dts-rollup.js';
+export { DefaultedInfiniteQueryObserverOptions } from './_tsup-dts-rollup.js';
+export { FetchQueryOptions } from './_tsup-dts-rollup.js';
+export { EnsureQueryDataOptions } from './_tsup-dts-rollup.js';
+export { EnsureInfiniteQueryDataOptions } from './_tsup-dts-rollup.js';
+export { FetchInfiniteQueryOptions } from './_tsup-dts-rollup.js';
+export { ResultOptions } from './_tsup-dts-rollup.js';
+export { RefetchOptions } from './_tsup-dts-rollup.js';
+export { InvalidateQueryFilters } from './_tsup-dts-rollup.js';
+export { RefetchQueryFilters } from './_tsup-dts-rollup.js';
+export { InvalidateOptions } from './_tsup-dts-rollup.js';
+export { ResetOptions } from './_tsup-dts-rollup.js';
+export { FetchNextPageOptions } from './_tsup-dts-rollup.js';
+export { FetchPreviousPageOptions } from './_tsup-dts-rollup.js';
+export { QueryStatus } from './_tsup-dts-rollup.js';
+export { FetchStatus } from './_tsup-dts-rollup.js';
+export { QueryObserverBaseResult } from './_tsup-dts-rollup.js';
+export { QueryObserverPendingResult } from './_tsup-dts-rollup.js';
+export { QueryObserverLoadingResult } from './_tsup-dts-rollup.js';
+export { QueryObserverLoadingErrorResult } from './_tsup-dts-rollup.js';
+export { QueryObserverRefetchErrorResult } from './_tsup-dts-rollup.js';
+export { QueryObserverSuccessResult } from './_tsup-dts-rollup.js';
+export { QueryObserverPlaceholderResult } from './_tsup-dts-rollup.js';
+export { DefinedQueryObserverResult } from './_tsup-dts-rollup.js';
+export { QueryObserverResult } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserverBaseResult } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserverPendingResult } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserverLoadingResult } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserverLoadingErrorResult } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserverRefetchErrorResult } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserverSuccessResult } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserverPlaceholderResult } from './_tsup-dts-rollup.js';
+export { DefinedInfiniteQueryObserverResult } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserverResult } from './_tsup-dts-rollup.js';
+export { MutationKey } from './_tsup-dts-rollup.js';
+export { MutationStatus } from './_tsup-dts-rollup.js';
+export { MutationScope } from './_tsup-dts-rollup.js';
+export { MutationMeta } from './_tsup-dts-rollup.js';
+export { MutationFunctionContext } from './_tsup-dts-rollup.js';
+export { MutationFunction } from './_tsup-dts-rollup.js';
+export { MutationOptions } from './_tsup-dts-rollup.js';
+export { MutationObserverOptions } from './_tsup-dts-rollup.js';
+export { MutateOptions } from './_tsup-dts-rollup.js';
+export { MutateFunction } from './_tsup-dts-rollup.js';
+export { MutationObserverBaseResult } from './_tsup-dts-rollup.js';
+export { MutationObserverIdleResult } from './_tsup-dts-rollup.js';
+export { MutationObserverLoadingResult } from './_tsup-dts-rollup.js';
+export { MutationObserverErrorResult } from './_tsup-dts-rollup.js';
+export { MutationObserverSuccessResult } from './_tsup-dts-rollup.js';
+export { MutationObserverResult } from './_tsup-dts-rollup.js';
+export { CancelOptions } from './_tsup-dts-rollup.js';
+export { SetDataOptions } from './_tsup-dts-rollup.js';
+export { NotifyEventType } from './_tsup-dts-rollup.js';
+export { NotifyEvent } from './_tsup-dts-rollup.js';

node_modules/@tanstack/solid-query/build/dev.js

@@ -0,0 +1,530 @@
+import { MutationObserver, shouldThrowError, QueriesObserver, noop, QueryClient as QueryClient$1, replaceEqualDeep, hydrate, notifyManager, QueryObserver, InfiniteQueryObserver } from '@tanstack/query-core';
+export * from '@tanstack/query-core';
+import { createContext, useContext, createRenderEffect, onCleanup, createMemo, createComputed, on, mergeProps, createResource, batch, onMount, createSignal, createEffect } from 'solid-js';
+import { createComponent, isServer } from 'solid-js/web';
+import { createStore, unwrap, reconcile } from 'solid-js/store';
+
+// src/useQuery.ts
+var QueryClientContext = createContext(void 0);
+var useQueryClient = (queryClient) => {
+  if (queryClient) {
+    return queryClient;
+  }
+  const client = useContext(QueryClientContext);
+  if (!client) {
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  }
+  return client();
+};
+var QueryClientProvider = (props) => {
+  createRenderEffect((unmount) => {
+    unmount?.();
+    props.client.mount();
+    return props.client.unmount.bind(props.client);
+  });
+  onCleanup(() => props.client.unmount());
+  return createComponent(QueryClientContext.Provider, {
+    value: () => props.client,
+    get children() {
+      return props.children;
+    }
+  });
+};
+var IsRestoringContext = createContext(() => false);
+var useIsRestoring = () => useContext(IsRestoringContext);
+var IsRestoringProvider = IsRestoringContext.Provider;
+
+// src/useBaseQuery.ts
+function reconcileFn(store, result, reconcileOption, queryHash) {
+  if (reconcileOption === false) return result;
+  if (typeof reconcileOption === "function") {
+    const newData2 = reconcileOption(store.data, result.data);
+    return { ...result, data: newData2 };
+  }
+  let data = result.data;
+  if (store.data === void 0) {
+    try {
+      data = structuredClone(data);
+    } catch (error) {
+      {
+        if (error instanceof Error) {
+          console.warn(
+            `Unable to correctly reconcile data for query key: ${queryHash}. Possibly because the query data contains data structures that aren't supported by the 'structuredClone' algorithm. Consider using a callback function instead to manage the reconciliation manually.
+
+ Error Received: ${error.name} - ${error.message}`
+          );
+        }
+      }
+    }
+  }
+  const newData = reconcile(data, { key: reconcileOption })(store.data);
+  return { ...result, data: newData };
+}
+var hydratableObserverResult = (query, result) => {
+  if (!isServer) return result;
+  const obj = {
+    ...unwrap(result),
+    // During SSR, functions cannot be serialized, so we need to remove them
+    // This is safe because we will add these functions back when the query is hydrated
+    refetch: void 0
+  };
+  if ("fetchNextPage" in result) {
+    obj.fetchNextPage = void 0;
+    obj.fetchPreviousPage = void 0;
+  }
+  obj.hydrationData = {
+    state: query.state,
+    queryKey: query.queryKey,
+    queryHash: query.queryHash,
+    ...query.meta && { meta: query.meta }
+  };
+  return obj;
+};
+function useBaseQuery(options, Observer, queryClient) {
+  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const isRestoring = useIsRestoring();
+  let unsubscribeQueued = false;
+  const defaultedOptions = createMemo(() => {
+    const defaultOptions = client().defaultQueryOptions(options());
+    defaultOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
+    defaultOptions.structuralSharing = false;
+    if (isServer) {
+      defaultOptions.retry = false;
+      defaultOptions.throwOnError = true;
+      defaultOptions.experimental_prefetchInRender = true;
+    }
+    return defaultOptions;
+  });
+  const initialOptions = defaultedOptions();
+  const [observer, setObserver] = createSignal(
+    new Observer(client(), defaultedOptions())
+  );
+  let observerResult = observer().getOptimisticResult(defaultedOptions());
+  const [state, setState] = createStore(observerResult);
+  const createServerSubscriber = (resolve, reject) => {
+    return observer().subscribe((result) => {
+      notifyManager.batchCalls(() => {
+        const query = observer().getCurrentQuery();
+        const unwrappedResult = hydratableObserverResult(query, result);
+        if (result.data !== void 0 && unwrappedResult.isError) {
+          reject(unwrappedResult.error);
+          unsubscribeIfQueued();
+        } else {
+          resolve(unwrappedResult);
+          unsubscribeIfQueued();
+        }
+      })();
+    });
+  };
+  const unsubscribeIfQueued = () => {
+    if (unsubscribeQueued) {
+      unsubscribe?.();
+      unsubscribeQueued = false;
+    }
+  };
+  const createClientSubscriber = () => {
+    const obs = observer();
+    return obs.subscribe((result) => {
+      observerResult = result;
+      queueMicrotask(() => {
+        if (unsubscribe) {
+          refetch();
+        }
+      });
+    });
+  };
+  function setStateWithReconciliation(res) {
+    const opts = observer().options;
+    const reconcileOptions = opts.reconcile;
+    setState((store) => {
+      return reconcileFn(
+        store,
+        res,
+        reconcileOptions === void 0 ? false : reconcileOptions,
+        opts.queryHash
+      );
+    });
+  }
+  function createDeepSignal() {
+    return [
+      () => state,
+      (v) => {
+        const unwrapped = unwrap(state);
+        if (typeof v === "function") {
+          v = v(unwrapped);
+        }
+        if (v?.hydrationData) {
+          const { hydrationData, ...rest } = v;
+          v = rest;
+        }
+        setStateWithReconciliation(v);
+      }
+    ];
+  }
+  let unsubscribe = null;
+  let resolver = null;
+  const [queryResource, { refetch }] = createResource(
+    () => {
+      const obs = observer();
+      return new Promise((resolve, reject) => {
+        resolver = resolve;
+        if (isServer) {
+          unsubscribe = createServerSubscriber(resolve, reject);
+        } else if (!unsubscribe && !isRestoring()) {
+          unsubscribe = createClientSubscriber();
+        }
+        obs.updateResult();
+        if (observerResult.isError && !observerResult.isFetching && !isRestoring() && shouldThrowError(obs.options.throwOnError, [
+          observerResult.error,
+          obs.getCurrentQuery()
+        ])) {
+          setStateWithReconciliation(observerResult);
+          return reject(observerResult.error);
+        }
+        if (!observerResult.isLoading) {
+          resolver = null;
+          return resolve(
+            hydratableObserverResult(obs.getCurrentQuery(), observerResult)
+          );
+        }
+        setStateWithReconciliation(observerResult);
+      });
+    },
+    {
+      storage: createDeepSignal,
+      get deferStream() {
+        return options().deferStream;
+      },
+      /**
+       * If this resource was populated on the server (either sync render, or streamed in over time), onHydrated
+       * will be called. This is the point at which we can hydrate the query cache state, and setup the query subscriber.
+       *
+       * Leveraging onHydrated allows us to plug into the async and streaming support that solidjs resources already support.
+       *
+       * Note that this is only invoked on the client, for queries that were originally run on the server.
+       */
+      onHydrated(_k, info) {
+        if (info.value && "hydrationData" in info.value) {
+          hydrate(client(), {
+            // @ts-expect-error - hydrationData is not correctly typed internally
+            queries: [{ ...info.value.hydrationData }]
+          });
+        }
+        if (unsubscribe) return;
+        const newOptions = { ...initialOptions };
+        if ((initialOptions.staleTime || !initialOptions.initialData) && info.value) {
+          newOptions.refetchOnMount = false;
+        }
+        observer().setOptions(newOptions);
+        setStateWithReconciliation(observer().getOptimisticResult(newOptions));
+        unsubscribe = createClientSubscriber();
+      }
+    }
+  );
+  createComputed(
+    on(
+      client,
+      (c) => {
+        if (unsubscribe) {
+          unsubscribe();
+        }
+        const newObserver = new Observer(c, defaultedOptions());
+        unsubscribe = createClientSubscriber();
+        setObserver(newObserver);
+      },
+      {
+        defer: true
+      }
+    )
+  );
+  createComputed(
+    on(
+      isRestoring,
+      (restoring) => {
+        if (!restoring && !isServer) {
+          refetch();
+        }
+      },
+      { defer: true }
+    )
+  );
+  onCleanup(() => {
+    if (isServer && queryResource.loading) {
+      unsubscribeQueued = true;
+      return;
+    }
+    if (unsubscribe) {
+      unsubscribe();
+      unsubscribe = null;
+    }
+    if (resolver && !isServer) {
+      resolver(observerResult);
+      resolver = null;
+    }
+  });
+  createComputed(
+    on(
+      [observer, defaultedOptions],
+      ([obs, opts]) => {
+        obs.setOptions(opts);
+        setStateWithReconciliation(obs.getOptimisticResult(opts));
+        refetch();
+      },
+      { defer: true }
+    )
+  );
+  const handler = {
+    get(target, prop) {
+      if (prop === "data") {
+        if (state.data !== void 0) {
+          return queryResource.latest?.data;
+        }
+        return queryResource()?.data;
+      }
+      return Reflect.get(target, prop);
+    }
+  };
+  return new Proxy(state, handler);
+}
+
+// src/useQuery.ts
+function useQuery(options, queryClient) {
+  return useBaseQuery(
+    createMemo(() => options()),
+    QueryObserver,
+    queryClient
+  );
+}
+function useInfiniteQuery(options, queryClient) {
+  return useBaseQuery(
+    createMemo(() => options()),
+    InfiniteQueryObserver,
+    queryClient
+  );
+}
+function useMutation(options, queryClient) {
+  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const observer = new MutationObserver(client(), options());
+  const mutate = (variables, mutateOptions) => {
+    observer.mutate(variables, mutateOptions).catch(noop);
+  };
+  const [state, setState] = createStore({
+    ...observer.getCurrentResult(),
+    mutate,
+    mutateAsync: observer.getCurrentResult().mutate
+  });
+  createComputed(() => {
+    observer.setOptions(options());
+  });
+  createComputed(
+    on(
+      () => state.status,
+      () => {
+        if (state.isError && shouldThrowError(observer.options.throwOnError, [state.error])) {
+          throw state.error;
+        }
+      }
+    )
+  );
+  const unsubscribe = observer.subscribe((result) => {
+    setState({
+      ...result,
+      mutate,
+      mutateAsync: result.mutate
+    });
+  });
+  onCleanup(unsubscribe);
+  return state;
+}
+function useQueries(queriesOptions, queryClient) {
+  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const isRestoring = useIsRestoring();
+  const defaultedQueries = createMemo(
+    () => queriesOptions().queries.map(
+      (options) => mergeProps(
+        client().defaultQueryOptions(options),
+        {
+          get _optimisticResults() {
+            return isRestoring() ? "isRestoring" : "optimistic";
+          }
+        }
+      )
+    )
+  );
+  const observer = new QueriesObserver(
+    client(),
+    defaultedQueries(),
+    queriesOptions().combine ? {
+      combine: queriesOptions().combine
+    } : void 0
+  );
+  const [state, setState] = createStore(
+    observer.getOptimisticResult(
+      defaultedQueries(),
+      queriesOptions().combine
+    )[1]()
+  );
+  createRenderEffect(
+    on(
+      () => queriesOptions().queries.length,
+      () => setState(
+        observer.getOptimisticResult(
+          defaultedQueries(),
+          queriesOptions().combine
+        )[1]()
+      )
+    )
+  );
+  const dataResources = createMemo(
+    on(
+      () => state.length,
+      () => state.map((queryRes) => {
+        const dataPromise = () => new Promise((resolve) => {
+          if (queryRes.isFetching && queryRes.isLoading) return;
+          resolve(unwrap(queryRes.data));
+        });
+        return createResource(dataPromise);
+      })
+    )
+  );
+  batch(() => {
+    const dataResources_ = dataResources();
+    for (let index = 0; index < dataResources_.length; index++) {
+      const dataResource = dataResources_[index];
+      dataResource[1].mutate(() => unwrap(state[index].data));
+      dataResource[1].refetch();
+    }
+  });
+  let taskQueue = [];
+  const subscribeToObserver = () => observer.subscribe((result) => {
+    taskQueue.push(() => {
+      batch(() => {
+        const dataResources_ = dataResources();
+        for (let index = 0; index < dataResources_.length; index++) {
+          const dataResource = dataResources_[index];
+          const unwrappedResult = { ...unwrap(result[index]) };
+          setState(index, unwrap(unwrappedResult));
+          dataResource[1].mutate(() => unwrap(state[index].data));
+          dataResource[1].refetch();
+        }
+      });
+    });
+    queueMicrotask(() => {
+      const taskToRun = taskQueue.pop();
+      if (taskToRun) taskToRun();
+      taskQueue = [];
+    });
+  });
+  let unsubscribe = noop;
+  createComputed((cleanup) => {
+    cleanup?.();
+    unsubscribe = isRestoring() ? noop : subscribeToObserver();
+    return () => queueMicrotask(unsubscribe);
+  });
+  onCleanup(unsubscribe);
+  onMount(() => {
+    observer.setQueries(
+      defaultedQueries(),
+      queriesOptions().combine ? {
+        combine: queriesOptions().combine
+      } : void 0
+    );
+  });
+  createComputed(() => {
+    observer.setQueries(
+      defaultedQueries(),
+      queriesOptions().combine ? {
+        combine: queriesOptions().combine
+      } : void 0
+    );
+  });
+  const handler = (index) => ({
+    get(target, prop) {
+      if (prop === "data") {
+        return dataResources()[index][0]();
+      }
+      return Reflect.get(target, prop);
+    }
+  });
+  const getProxies = () => state.map((s, index) => {
+    return new Proxy(s, handler(index));
+  });
+  const [proxyState, setProxyState] = createStore(getProxies());
+  createRenderEffect(() => setProxyState(getProxies()));
+  return proxyState;
+}
+var QueryClient = class extends QueryClient$1 {
+  constructor(config = {}) {
+    super(config);
+  }
+};
+
+// src/queryOptions.ts
+function queryOptions(options) {
+  return options;
+}
+function useIsFetching(filters, queryClient) {
+  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const queryCache = createMemo(() => client().getQueryCache());
+  const [fetches, setFetches] = createSignal(client().isFetching(filters?.()));
+  const unsubscribe = queryCache().subscribe(() => {
+    setFetches(client().isFetching(filters?.()));
+  });
+  onCleanup(unsubscribe);
+  return fetches;
+}
+
+// src/infiniteQueryOptions.ts
+function infiniteQueryOptions(options) {
+  return options;
+}
+
+// src/mutationOptions.ts
+function mutationOptions(options) {
+  return options;
+}
+function useIsMutating(filters, queryClient) {
+  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const mutationCache = createMemo(() => client().getMutationCache());
+  const [mutations, setMutations] = createSignal(
+    client().isMutating(filters?.())
+  );
+  const unsubscribe = mutationCache().subscribe((_result) => {
+    setMutations(client().isMutating(filters?.()));
+  });
+  onCleanup(unsubscribe);
+  return mutations;
+}
+function getResult(mutationCache, options) {
+  return mutationCache.findAll(options.filters).map(
+    (mutation) => options.select ? options.select(mutation) : mutation.state
+  );
+}
+function useMutationState(options = () => ({}), queryClient) {
+  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const mutationCache = createMemo(() => client().getMutationCache());
+  const [result, setResult] = createSignal(
+    getResult(mutationCache(), options())
+  );
+  createEffect(() => {
+    const unsubscribe = mutationCache().subscribe(() => {
+      const nextResult = replaceEqualDeep(
+        result(),
+        getResult(mutationCache(), options())
+      );
+      if (result() !== nextResult) {
+        setResult(nextResult);
+      }
+    });
+    onCleanup(unsubscribe);
+  });
+  return result;
+}
+
+// src/index.ts
+var createQuery = useQuery;
+var createInfiniteQuery = useInfiniteQuery;
+var createMutation = useMutation;
+var createQueries = useQueries;
+
+export { IsRestoringProvider, QueryClient, QueryClientContext, QueryClientProvider, createInfiniteQuery, useIsFetching as createIsFetching, useIsMutating as createIsMutating, createMutation, useMutationState as createMutationState, createQueries, createQuery, infiniteQueryOptions, mutationOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, useQueries, useQuery, useQueryClient };

node_modules/@tanstack/solid-query/build/index.cjs

@@ -0,0 +1,540 @@
+'use strict';
+
+var queryCore = require('@tanstack/query-core');
+var solidJs = require('solid-js');
+var web = require('solid-js/web');
+var store = require('solid-js/store');
+
+// src/useQuery.ts
+exports.QueryClientContext = solidJs.createContext(void 0);
+exports.useQueryClient = (queryClient) => {
+  if (queryClient) {
+    return queryClient;
+  }
+  const client = solidJs.useContext(exports.QueryClientContext);
+  if (!client) {
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  }
+  return client();
+};
+exports.QueryClientProvider = (props) => {
+  solidJs.createRenderEffect((unmount) => {
+    unmount?.();
+    props.client.mount();
+    return props.client.unmount.bind(props.client);
+  });
+  solidJs.onCleanup(() => props.client.unmount());
+  return web.createComponent(exports.QueryClientContext.Provider, {
+    value: () => props.client,
+    get children() {
+      return props.children;
+    }
+  });
+};
+var IsRestoringContext = solidJs.createContext(() => false);
+exports.useIsRestoring = () => solidJs.useContext(IsRestoringContext);
+exports.IsRestoringProvider = IsRestoringContext.Provider;
+
+// src/useBaseQuery.ts
+function reconcileFn(store$1, result, reconcileOption, queryHash) {
+  if (reconcileOption === false) return result;
+  if (typeof reconcileOption === "function") {
+    const newData2 = reconcileOption(store$1.data, result.data);
+    return { ...result, data: newData2 };
+  }
+  let data = result.data;
+  if (store$1.data === void 0) {
+    try {
+      data = structuredClone(data);
+    } catch (error) {
+    }
+  }
+  const newData = store.reconcile(data, { key: reconcileOption })(store$1.data);
+  return { ...result, data: newData };
+}
+var hydratableObserverResult = (query, result) => {
+  if (!web.isServer) return result;
+  const obj = {
+    ...store.unwrap(result),
+    // During SSR, functions cannot be serialized, so we need to remove them
+    // This is safe because we will add these functions back when the query is hydrated
+    refetch: void 0
+  };
+  if ("fetchNextPage" in result) {
+    obj.fetchNextPage = void 0;
+    obj.fetchPreviousPage = void 0;
+  }
+  obj.hydrationData = {
+    state: query.state,
+    queryKey: query.queryKey,
+    queryHash: query.queryHash,
+    ...query.meta && { meta: query.meta }
+  };
+  return obj;
+};
+function useBaseQuery(options, Observer, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const isRestoring = exports.useIsRestoring();
+  let unsubscribeQueued = false;
+  const defaultedOptions = solidJs.createMemo(() => {
+    const defaultOptions = client().defaultQueryOptions(options());
+    defaultOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
+    defaultOptions.structuralSharing = false;
+    if (web.isServer) {
+      defaultOptions.retry = false;
+      defaultOptions.throwOnError = true;
+      defaultOptions.experimental_prefetchInRender = true;
+    }
+    return defaultOptions;
+  });
+  const initialOptions = defaultedOptions();
+  const [observer, setObserver] = solidJs.createSignal(
+    new Observer(client(), defaultedOptions())
+  );
+  let observerResult = observer().getOptimisticResult(defaultedOptions());
+  const [state, setState] = store.createStore(observerResult);
+  const createServerSubscriber = (resolve, reject) => {
+    return observer().subscribe((result) => {
+      queryCore.notifyManager.batchCalls(() => {
+        const query = observer().getCurrentQuery();
+        const unwrappedResult = hydratableObserverResult(query, result);
+        if (result.data !== void 0 && unwrappedResult.isError) {
+          reject(unwrappedResult.error);
+          unsubscribeIfQueued();
+        } else {
+          resolve(unwrappedResult);
+          unsubscribeIfQueued();
+        }
+      })();
+    });
+  };
+  const unsubscribeIfQueued = () => {
+    if (unsubscribeQueued) {
+      unsubscribe?.();
+      unsubscribeQueued = false;
+    }
+  };
+  const createClientSubscriber = () => {
+    const obs = observer();
+    return obs.subscribe((result) => {
+      observerResult = result;
+      queueMicrotask(() => {
+        if (unsubscribe) {
+          refetch();
+        }
+      });
+    });
+  };
+  function setStateWithReconciliation(res) {
+    const opts = observer().options;
+    const reconcileOptions = opts.reconcile;
+    setState((store) => {
+      return reconcileFn(
+        store,
+        res,
+        reconcileOptions === void 0 ? false : reconcileOptions,
+        opts.queryHash
+      );
+    });
+  }
+  function createDeepSignal() {
+    return [
+      () => state,
+      (v) => {
+        const unwrapped = store.unwrap(state);
+        if (typeof v === "function") {
+          v = v(unwrapped);
+        }
+        if (v?.hydrationData) {
+          const { hydrationData, ...rest } = v;
+          v = rest;
+        }
+        setStateWithReconciliation(v);
+      }
+    ];
+  }
+  let unsubscribe = null;
+  let resolver = null;
+  const [queryResource, { refetch }] = solidJs.createResource(
+    () => {
+      const obs = observer();
+      return new Promise((resolve, reject) => {
+        resolver = resolve;
+        if (web.isServer) {
+          unsubscribe = createServerSubscriber(resolve, reject);
+        } else if (!unsubscribe && !isRestoring()) {
+          unsubscribe = createClientSubscriber();
+        }
+        obs.updateResult();
+        if (observerResult.isError && !observerResult.isFetching && !isRestoring() && queryCore.shouldThrowError(obs.options.throwOnError, [
+          observerResult.error,
+          obs.getCurrentQuery()
+        ])) {
+          setStateWithReconciliation(observerResult);
+          return reject(observerResult.error);
+        }
+        if (!observerResult.isLoading) {
+          resolver = null;
+          return resolve(
+            hydratableObserverResult(obs.getCurrentQuery(), observerResult)
+          );
+        }
+        setStateWithReconciliation(observerResult);
+      });
+    },
+    {
+      storage: createDeepSignal,
+      get deferStream() {
+        return options().deferStream;
+      },
+      /**
+       * If this resource was populated on the server (either sync render, or streamed in over time), onHydrated
+       * will be called. This is the point at which we can hydrate the query cache state, and setup the query subscriber.
+       *
+       * Leveraging onHydrated allows us to plug into the async and streaming support that solidjs resources already support.
+       *
+       * Note that this is only invoked on the client, for queries that were originally run on the server.
+       */
+      onHydrated(_k, info) {
+        if (info.value && "hydrationData" in info.value) {
+          queryCore.hydrate(client(), {
+            // @ts-expect-error - hydrationData is not correctly typed internally
+            queries: [{ ...info.value.hydrationData }]
+          });
+        }
+        if (unsubscribe) return;
+        const newOptions = { ...initialOptions };
+        if ((initialOptions.staleTime || !initialOptions.initialData) && info.value) {
+          newOptions.refetchOnMount = false;
+        }
+        observer().setOptions(newOptions);
+        setStateWithReconciliation(observer().getOptimisticResult(newOptions));
+        unsubscribe = createClientSubscriber();
+      }
+    }
+  );
+  solidJs.createComputed(
+    solidJs.on(
+      client,
+      (c) => {
+        if (unsubscribe) {
+          unsubscribe();
+        }
+        const newObserver = new Observer(c, defaultedOptions());
+        unsubscribe = createClientSubscriber();
+        setObserver(newObserver);
+      },
+      {
+        defer: true
+      }
+    )
+  );
+  solidJs.createComputed(
+    solidJs.on(
+      isRestoring,
+      (restoring) => {
+        if (!restoring && !web.isServer) {
+          refetch();
+        }
+      },
+      { defer: true }
+    )
+  );
+  solidJs.onCleanup(() => {
+    if (web.isServer && queryResource.loading) {
+      unsubscribeQueued = true;
+      return;
+    }
+    if (unsubscribe) {
+      unsubscribe();
+      unsubscribe = null;
+    }
+    if (resolver && !web.isServer) {
+      resolver(observerResult);
+      resolver = null;
+    }
+  });
+  solidJs.createComputed(
+    solidJs.on(
+      [observer, defaultedOptions],
+      ([obs, opts]) => {
+        obs.setOptions(opts);
+        setStateWithReconciliation(obs.getOptimisticResult(opts));
+        refetch();
+      },
+      { defer: true }
+    )
+  );
+  const handler = {
+    get(target, prop) {
+      if (prop === "data") {
+        if (state.data !== void 0) {
+          return queryResource.latest?.data;
+        }
+        return queryResource()?.data;
+      }
+      return Reflect.get(target, prop);
+    }
+  };
+  return new Proxy(state, handler);
+}
+
+// src/useQuery.ts
+function useQuery(options, queryClient) {
+  return useBaseQuery(
+    solidJs.createMemo(() => options()),
+    queryCore.QueryObserver,
+    queryClient
+  );
+}
+function useInfiniteQuery(options, queryClient) {
+  return useBaseQuery(
+    solidJs.createMemo(() => options()),
+    queryCore.InfiniteQueryObserver,
+    queryClient
+  );
+}
+function useMutation(options, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const observer = new queryCore.MutationObserver(client(), options());
+  const mutate = (variables, mutateOptions) => {
+    observer.mutate(variables, mutateOptions).catch(queryCore.noop);
+  };
+  const [state, setState] = store.createStore({
+    ...observer.getCurrentResult(),
+    mutate,
+    mutateAsync: observer.getCurrentResult().mutate
+  });
+  solidJs.createComputed(() => {
+    observer.setOptions(options());
+  });
+  solidJs.createComputed(
+    solidJs.on(
+      () => state.status,
+      () => {
+        if (state.isError && queryCore.shouldThrowError(observer.options.throwOnError, [state.error])) {
+          throw state.error;
+        }
+      }
+    )
+  );
+  const unsubscribe = observer.subscribe((result) => {
+    setState({
+      ...result,
+      mutate,
+      mutateAsync: result.mutate
+    });
+  });
+  solidJs.onCleanup(unsubscribe);
+  return state;
+}
+function useQueries(queriesOptions, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const isRestoring = exports.useIsRestoring();
+  const defaultedQueries = solidJs.createMemo(
+    () => queriesOptions().queries.map(
+      (options) => solidJs.mergeProps(
+        client().defaultQueryOptions(options),
+        {
+          get _optimisticResults() {
+            return isRestoring() ? "isRestoring" : "optimistic";
+          }
+        }
+      )
+    )
+  );
+  const observer = new queryCore.QueriesObserver(
+    client(),
+    defaultedQueries(),
+    queriesOptions().combine ? {
+      combine: queriesOptions().combine
+    } : void 0
+  );
+  const [state, setState] = store.createStore(
+    observer.getOptimisticResult(
+      defaultedQueries(),
+      queriesOptions().combine
+    )[1]()
+  );
+  solidJs.createRenderEffect(
+    solidJs.on(
+      () => queriesOptions().queries.length,
+      () => setState(
+        observer.getOptimisticResult(
+          defaultedQueries(),
+          queriesOptions().combine
+        )[1]()
+      )
+    )
+  );
+  const dataResources = solidJs.createMemo(
+    solidJs.on(
+      () => state.length,
+      () => state.map((queryRes) => {
+        const dataPromise = () => new Promise((resolve) => {
+          if (queryRes.isFetching && queryRes.isLoading) return;
+          resolve(store.unwrap(queryRes.data));
+        });
+        return solidJs.createResource(dataPromise);
+      })
+    )
+  );
+  solidJs.batch(() => {
+    const dataResources_ = dataResources();
+    for (let index = 0; index < dataResources_.length; index++) {
+      const dataResource = dataResources_[index];
+      dataResource[1].mutate(() => store.unwrap(state[index].data));
+      dataResource[1].refetch();
+    }
+  });
+  let taskQueue = [];
+  const subscribeToObserver = () => observer.subscribe((result) => {
+    taskQueue.push(() => {
+      solidJs.batch(() => {
+        const dataResources_ = dataResources();
+        for (let index = 0; index < dataResources_.length; index++) {
+          const dataResource = dataResources_[index];
+          const unwrappedResult = { ...store.unwrap(result[index]) };
+          setState(index, store.unwrap(unwrappedResult));
+          dataResource[1].mutate(() => store.unwrap(state[index].data));
+          dataResource[1].refetch();
+        }
+      });
+    });
+    queueMicrotask(() => {
+      const taskToRun = taskQueue.pop();
+      if (taskToRun) taskToRun();
+      taskQueue = [];
+    });
+  });
+  let unsubscribe = queryCore.noop;
+  solidJs.createComputed((cleanup) => {
+    cleanup?.();
+    unsubscribe = isRestoring() ? queryCore.noop : subscribeToObserver();
+    return () => queueMicrotask(unsubscribe);
+  });
+  solidJs.onCleanup(unsubscribe);
+  solidJs.onMount(() => {
+    observer.setQueries(
+      defaultedQueries(),
+      queriesOptions().combine ? {
+        combine: queriesOptions().combine
+      } : void 0
+    );
+  });
+  solidJs.createComputed(() => {
+    observer.setQueries(
+      defaultedQueries(),
+      queriesOptions().combine ? {
+        combine: queriesOptions().combine
+      } : void 0
+    );
+  });
+  const handler = (index) => ({
+    get(target, prop) {
+      if (prop === "data") {
+        return dataResources()[index][0]();
+      }
+      return Reflect.get(target, prop);
+    }
+  });
+  const getProxies = () => state.map((s, index) => {
+    return new Proxy(s, handler(index));
+  });
+  const [proxyState, setProxyState] = store.createStore(getProxies());
+  solidJs.createRenderEffect(() => setProxyState(getProxies()));
+  return proxyState;
+}
+exports.QueryClient = class QueryClient extends queryCore.QueryClient {
+  constructor(config = {}) {
+    super(config);
+  }
+};
+
+// src/queryOptions.ts
+function queryOptions(options) {
+  return options;
+}
+function useIsFetching(filters, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const queryCache = solidJs.createMemo(() => client().getQueryCache());
+  const [fetches, setFetches] = solidJs.createSignal(client().isFetching(filters?.()));
+  const unsubscribe = queryCache().subscribe(() => {
+    setFetches(client().isFetching(filters?.()));
+  });
+  solidJs.onCleanup(unsubscribe);
+  return fetches;
+}
+
+// src/infiniteQueryOptions.ts
+function infiniteQueryOptions(options) {
+  return options;
+}
+
+// src/mutationOptions.ts
+function mutationOptions(options) {
+  return options;
+}
+function useIsMutating(filters, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const mutationCache = solidJs.createMemo(() => client().getMutationCache());
+  const [mutations, setMutations] = solidJs.createSignal(
+    client().isMutating(filters?.())
+  );
+  const unsubscribe = mutationCache().subscribe((_result) => {
+    setMutations(client().isMutating(filters?.()));
+  });
+  solidJs.onCleanup(unsubscribe);
+  return mutations;
+}
+function getResult(mutationCache, options) {
+  return mutationCache.findAll(options.filters).map(
+    (mutation) => options.select ? options.select(mutation) : mutation.state
+  );
+}
+function useMutationState(options = () => ({}), queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const mutationCache = solidJs.createMemo(() => client().getMutationCache());
+  const [result, setResult] = solidJs.createSignal(
+    getResult(mutationCache(), options())
+  );
+  solidJs.createEffect(() => {
+    const unsubscribe = mutationCache().subscribe(() => {
+      const nextResult = queryCore.replaceEqualDeep(
+        result(),
+        getResult(mutationCache(), options())
+      );
+      if (result() !== nextResult) {
+        setResult(nextResult);
+      }
+    });
+    solidJs.onCleanup(unsubscribe);
+  });
+  return result;
+}
+
+// src/index.ts
+exports.createQuery = useQuery;
+exports.createInfiniteQuery = useInfiniteQuery;
+exports.createMutation = useMutation;
+exports.createQueries = useQueries;
+
+exports.createIsFetching = useIsFetching;
+exports.createIsMutating = useIsMutating;
+exports.createMutationState = useMutationState;
+exports.infiniteQueryOptions = infiniteQueryOptions;
+exports.mutationOptions = mutationOptions;
+exports.queryOptions = queryOptions;
+exports.useInfiniteQuery = useInfiniteQuery;
+exports.useIsFetching = useIsFetching;
+exports.useIsMutating = useIsMutating;
+exports.useMutation = useMutation;
+exports.useMutationState = useMutationState;
+exports.useQueries = useQueries;
+exports.useQuery = useQuery;
+Object.keys(queryCore).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return queryCore[k]; }
+  });
+});

node_modules/@tanstack/solid-query/build/index.d.cts

@@ -0,0 +1,200 @@
+export { DefinedUseBaseQueryResult } from './_tsup-dts-rollup.cjs';
+export { DefinedUseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
+export { DefinedUseQueryResult } from './_tsup-dts-rollup.cjs';
+export { SolidInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
+export { SolidMutationOptions } from './_tsup-dts-rollup.cjs';
+export { SolidQueryOptions } from './_tsup-dts-rollup.cjs';
+export { UseBaseMutationResult } from './_tsup-dts-rollup.cjs';
+export { UseBaseQueryOptions } from './_tsup-dts-rollup.cjs';
+export { UseBaseQueryResult } from './_tsup-dts-rollup.cjs';
+export { UseInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
+export { UseInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
+export { UseMutateAsyncFunction } from './_tsup-dts-rollup.cjs';
+export { UseMutateFunction } from './_tsup-dts-rollup.cjs';
+export { UseMutationOptions } from './_tsup-dts-rollup.cjs';
+export { UseMutationResult } from './_tsup-dts-rollup.cjs';
+export { UseQueryOptions } from './_tsup-dts-rollup.cjs';
+export { UseQueryResult } from './_tsup-dts-rollup.cjs';
+export { CreateBaseQueryOptions } from './_tsup-dts-rollup.cjs';
+export { CreateBaseQueryResult } from './_tsup-dts-rollup.cjs';
+export { CreateInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
+export { CreateInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
+export { CreateMutateAsyncFunction } from './_tsup-dts-rollup.cjs';
+export { CreateMutateFunction } from './_tsup-dts-rollup.cjs';
+export { CreateMutationOptions } from './_tsup-dts-rollup.cjs';
+export { CreateMutationResult } from './_tsup-dts-rollup.cjs';
+export { CreateBaseMutationResult } from './_tsup-dts-rollup.cjs';
+export { CreateQueryOptions } from './_tsup-dts-rollup.cjs';
+export { CreateQueryResult } from './_tsup-dts-rollup.cjs';
+export { DefinedCreateBaseQueryResult } from './_tsup-dts-rollup.cjs';
+export { DefinedCreateInfiniteQueryResult } from './_tsup-dts-rollup.cjs';
+export { DefinedCreateQueryResult } from './_tsup-dts-rollup.cjs';
+export { QueryClient_alias_1 as QueryClient } from './_tsup-dts-rollup.cjs';
+export { QueryObserverOptions_alias_1 as QueryObserverOptions } from './_tsup-dts-rollup.cjs';
+export { DefaultOptions_alias_1 as DefaultOptions } from './_tsup-dts-rollup.cjs';
+export { QueryClientConfig_alias_1 as QueryClientConfig } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserverOptions_alias_1 as InfiniteQueryObserverOptions } from './_tsup-dts-rollup.cjs';
+export { useQuery } from './_tsup-dts-rollup.cjs';
+export { createQuery } from './_tsup-dts-rollup.cjs';
+export { queryOptions } from './_tsup-dts-rollup.cjs';
+export { DefinedInitialDataOptions } from './_tsup-dts-rollup.cjs';
+export { UndefinedInitialDataOptions } from './_tsup-dts-rollup.cjs';
+export { QueryClientContext_alias_1 as QueryClientContext } from './_tsup-dts-rollup.cjs';
+export { QueryClientProvider_alias_1 as QueryClientProvider } from './_tsup-dts-rollup.cjs';
+export { useQueryClient_alias_1 as useQueryClient } from './_tsup-dts-rollup.cjs';
+export { QueryClientProviderProps_alias_1 as QueryClientProviderProps } from './_tsup-dts-rollup.cjs';
+export { useIsFetching } from './_tsup-dts-rollup.cjs';
+export { createIsFetching } from './_tsup-dts-rollup.cjs';
+export { useInfiniteQuery } from './_tsup-dts-rollup.cjs';
+export { createInfiniteQuery } from './_tsup-dts-rollup.cjs';
+export { infiniteQueryOptions } from './_tsup-dts-rollup.cjs';
+export { DefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.cjs';
+export { UndefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.cjs';
+export { useMutation } from './_tsup-dts-rollup.cjs';
+export { mutationOptions } from './_tsup-dts-rollup.cjs';
+export { createMutation } from './_tsup-dts-rollup.cjs';
+export { useIsMutating } from './_tsup-dts-rollup.cjs';
+export { createIsMutating } from './_tsup-dts-rollup.cjs';
+export { useMutationState } from './_tsup-dts-rollup.cjs';
+export { createMutationState } from './_tsup-dts-rollup.cjs';
+export { useQueries } from './_tsup-dts-rollup.cjs';
+export { createQueries } from './_tsup-dts-rollup.cjs';
+export { useIsRestoring } from './_tsup-dts-rollup.cjs';
+export { IsRestoringProvider } from './_tsup-dts-rollup.cjs';
+export { focusManager } from './_tsup-dts-rollup.cjs';
+export { environmentManager } from './_tsup-dts-rollup.cjs';
+export { defaultShouldDehydrateMutation } from './_tsup-dts-rollup.cjs';
+export { defaultShouldDehydrateQuery } from './_tsup-dts-rollup.cjs';
+export { dehydrate } from './_tsup-dts-rollup.cjs';
+export { hydrate } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserver } from './_tsup-dts-rollup.cjs';
+export { MutationCache } from './_tsup-dts-rollup.cjs';
+export { MutationCacheNotifyEvent } from './_tsup-dts-rollup.cjs';
+export { MutationObserver } from './_tsup-dts-rollup.cjs';
+export { defaultScheduler } from './_tsup-dts-rollup.cjs';
+export { notifyManager } from './_tsup-dts-rollup.cjs';
+export { onlineManager } from './_tsup-dts-rollup.cjs';
+export { QueriesObserver } from './_tsup-dts-rollup.cjs';
+export { QueryCache } from './_tsup-dts-rollup.cjs';
+export { QueryCacheNotifyEvent } from './_tsup-dts-rollup.cjs';
+export { QueryObserver } from './_tsup-dts-rollup.cjs';
+export { CancelledError } from './_tsup-dts-rollup.cjs';
+export { isCancelledError } from './_tsup-dts-rollup.cjs';
+export { timeoutManager } from './_tsup-dts-rollup.cjs';
+export { ManagedTimerId } from './_tsup-dts-rollup.cjs';
+export { TimeoutCallback } from './_tsup-dts-rollup.cjs';
+export { TimeoutProvider } from './_tsup-dts-rollup.cjs';
+export { hashKey } from './_tsup-dts-rollup.cjs';
+export { isServer } from './_tsup-dts-rollup.cjs';
+export { keepPreviousData } from './_tsup-dts-rollup.cjs';
+export { matchMutation } from './_tsup-dts-rollup.cjs';
+export { matchQuery } from './_tsup-dts-rollup.cjs';
+export { noop } from './_tsup-dts-rollup.cjs';
+export { partialMatchKey } from './_tsup-dts-rollup.cjs';
+export { replaceEqualDeep } from './_tsup-dts-rollup.cjs';
+export { shouldThrowError } from './_tsup-dts-rollup.cjs';
+export { skipToken } from './_tsup-dts-rollup.cjs';
+export { MutationFilters } from './_tsup-dts-rollup.cjs';
+export { QueryFilters } from './_tsup-dts-rollup.cjs';
+export { SkipToken } from './_tsup-dts-rollup.cjs';
+export { Updater } from './_tsup-dts-rollup.cjs';
+export { experimental_streamedQuery } from './_tsup-dts-rollup.cjs';
+export { DehydratedState } from './_tsup-dts-rollup.cjs';
+export { DehydrateOptions } from './_tsup-dts-rollup.cjs';
+export { HydrateOptions } from './_tsup-dts-rollup.cjs';
+export { Mutation } from './_tsup-dts-rollup.cjs';
+export { MutationState } from './_tsup-dts-rollup.cjs';
+export { QueriesObserverOptions } from './_tsup-dts-rollup.cjs';
+export { Query } from './_tsup-dts-rollup.cjs';
+export { QueryState } from './_tsup-dts-rollup.cjs';
+export { NonUndefinedGuard } from './_tsup-dts-rollup.cjs';
+export { DistributiveOmit } from './_tsup-dts-rollup.cjs';
+export { OmitKeyof } from './_tsup-dts-rollup.cjs';
+export { Override } from './_tsup-dts-rollup.cjs';
+export { NoInfer } from './_tsup-dts-rollup.cjs';
+export { Register } from './_tsup-dts-rollup.cjs';
+export { DefaultError } from './_tsup-dts-rollup.cjs';
+export { QueryKey } from './_tsup-dts-rollup.cjs';
+export { dataTagSymbol } from './_tsup-dts-rollup.cjs';
+export { dataTagErrorSymbol } from './_tsup-dts-rollup.cjs';
+export { unsetMarker } from './_tsup-dts-rollup.cjs';
+export { UnsetMarker } from './_tsup-dts-rollup.cjs';
+export { AnyDataTag } from './_tsup-dts-rollup.cjs';
+export { DataTag } from './_tsup-dts-rollup.cjs';
+export { InferDataFromTag } from './_tsup-dts-rollup.cjs';
+export { InferErrorFromTag } from './_tsup-dts-rollup.cjs';
+export { QueryFunction } from './_tsup-dts-rollup.cjs';
+export { StaleTime } from './_tsup-dts-rollup.cjs';
+export { StaleTimeFunction } from './_tsup-dts-rollup.cjs';
+export { QueryBooleanOption } from './_tsup-dts-rollup.cjs';
+export { QueryPersister } from './_tsup-dts-rollup.cjs';
+export { QueryFunctionContext } from './_tsup-dts-rollup.cjs';
+export { InitialDataFunction } from './_tsup-dts-rollup.cjs';
+export { PlaceholderDataFunction } from './_tsup-dts-rollup.cjs';
+export { QueriesPlaceholderDataFunction } from './_tsup-dts-rollup.cjs';
+export { QueryKeyHashFunction } from './_tsup-dts-rollup.cjs';
+export { GetPreviousPageParamFunction } from './_tsup-dts-rollup.cjs';
+export { GetNextPageParamFunction } from './_tsup-dts-rollup.cjs';
+export { InfiniteData } from './_tsup-dts-rollup.cjs';
+export { QueryMeta } from './_tsup-dts-rollup.cjs';
+export { NetworkMode } from './_tsup-dts-rollup.cjs';
+export { NotifyOnChangeProps } from './_tsup-dts-rollup.cjs';
+export { QueryOptions } from './_tsup-dts-rollup.cjs';
+export { InitialPageParam } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryPageParamsOptions } from './_tsup-dts-rollup.cjs';
+export { ThrowOnError } from './_tsup-dts-rollup.cjs';
+export { WithRequired } from './_tsup-dts-rollup.cjs';
+export { DefaultedQueryObserverOptions } from './_tsup-dts-rollup.cjs';
+export { DefaultedInfiniteQueryObserverOptions } from './_tsup-dts-rollup.cjs';
+export { FetchQueryOptions } from './_tsup-dts-rollup.cjs';
+export { EnsureQueryDataOptions } from './_tsup-dts-rollup.cjs';
+export { EnsureInfiniteQueryDataOptions } from './_tsup-dts-rollup.cjs';
+export { FetchInfiniteQueryOptions } from './_tsup-dts-rollup.cjs';
+export { ResultOptions } from './_tsup-dts-rollup.cjs';
+export { RefetchOptions } from './_tsup-dts-rollup.cjs';
+export { InvalidateQueryFilters } from './_tsup-dts-rollup.cjs';
+export { RefetchQueryFilters } from './_tsup-dts-rollup.cjs';
+export { InvalidateOptions } from './_tsup-dts-rollup.cjs';
+export { ResetOptions } from './_tsup-dts-rollup.cjs';
+export { FetchNextPageOptions } from './_tsup-dts-rollup.cjs';
+export { FetchPreviousPageOptions } from './_tsup-dts-rollup.cjs';
+export { QueryStatus } from './_tsup-dts-rollup.cjs';
+export { FetchStatus } from './_tsup-dts-rollup.cjs';
+export { QueryObserverBaseResult } from './_tsup-dts-rollup.cjs';
+export { QueryObserverPendingResult } from './_tsup-dts-rollup.cjs';
+export { QueryObserverLoadingResult } from './_tsup-dts-rollup.cjs';
+export { QueryObserverLoadingErrorResult } from './_tsup-dts-rollup.cjs';
+export { QueryObserverRefetchErrorResult } from './_tsup-dts-rollup.cjs';
+export { QueryObserverSuccessResult } from './_tsup-dts-rollup.cjs';
+export { QueryObserverPlaceholderResult } from './_tsup-dts-rollup.cjs';
+export { DefinedQueryObserverResult } from './_tsup-dts-rollup.cjs';
+export { QueryObserverResult } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserverBaseResult } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserverPendingResult } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserverLoadingResult } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserverLoadingErrorResult } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserverRefetchErrorResult } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserverSuccessResult } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserverPlaceholderResult } from './_tsup-dts-rollup.cjs';
+export { DefinedInfiniteQueryObserverResult } from './_tsup-dts-rollup.cjs';
+export { InfiniteQueryObserverResult } from './_tsup-dts-rollup.cjs';
+export { MutationKey } from './_tsup-dts-rollup.cjs';
+export { MutationStatus } from './_tsup-dts-rollup.cjs';
+export { MutationScope } from './_tsup-dts-rollup.cjs';
+export { MutationMeta } from './_tsup-dts-rollup.cjs';
+export { MutationFunctionContext } from './_tsup-dts-rollup.cjs';
+export { MutationFunction } from './_tsup-dts-rollup.cjs';
+export { MutationOptions } from './_tsup-dts-rollup.cjs';
+export { MutationObserverOptions } from './_tsup-dts-rollup.cjs';
+export { MutateOptions } from './_tsup-dts-rollup.cjs';
+export { MutateFunction } from './_tsup-dts-rollup.cjs';
+export { MutationObserverBaseResult } from './_tsup-dts-rollup.cjs';
+export { MutationObserverIdleResult } from './_tsup-dts-rollup.cjs';
+export { MutationObserverLoadingResult } from './_tsup-dts-rollup.cjs';
+export { MutationObserverErrorResult } from './_tsup-dts-rollup.cjs';
+export { MutationObserverSuccessResult } from './_tsup-dts-rollup.cjs';
+export { MutationObserverResult } from './_tsup-dts-rollup.cjs';
+export { CancelOptions } from './_tsup-dts-rollup.cjs';
+export { SetDataOptions } from './_tsup-dts-rollup.cjs';
+export { NotifyEventType } from './_tsup-dts-rollup.cjs';
+export { NotifyEvent } from './_tsup-dts-rollup.cjs';

node_modules/@tanstack/solid-query/build/index.d.ts

@@ -0,0 +1,200 @@
+export { DefinedUseBaseQueryResult } from './_tsup-dts-rollup.js';
+export { DefinedUseInfiniteQueryResult } from './_tsup-dts-rollup.js';
+export { DefinedUseQueryResult } from './_tsup-dts-rollup.js';
+export { SolidInfiniteQueryOptions } from './_tsup-dts-rollup.js';
+export { SolidMutationOptions } from './_tsup-dts-rollup.js';
+export { SolidQueryOptions } from './_tsup-dts-rollup.js';
+export { UseBaseMutationResult } from './_tsup-dts-rollup.js';
+export { UseBaseQueryOptions } from './_tsup-dts-rollup.js';
+export { UseBaseQueryResult } from './_tsup-dts-rollup.js';
+export { UseInfiniteQueryOptions } from './_tsup-dts-rollup.js';
+export { UseInfiniteQueryResult } from './_tsup-dts-rollup.js';
+export { UseMutateAsyncFunction } from './_tsup-dts-rollup.js';
+export { UseMutateFunction } from './_tsup-dts-rollup.js';
+export { UseMutationOptions } from './_tsup-dts-rollup.js';
+export { UseMutationResult } from './_tsup-dts-rollup.js';
+export { UseQueryOptions } from './_tsup-dts-rollup.js';
+export { UseQueryResult } from './_tsup-dts-rollup.js';
+export { CreateBaseQueryOptions } from './_tsup-dts-rollup.js';
+export { CreateBaseQueryResult } from './_tsup-dts-rollup.js';
+export { CreateInfiniteQueryOptions } from './_tsup-dts-rollup.js';
+export { CreateInfiniteQueryResult } from './_tsup-dts-rollup.js';
+export { CreateMutateAsyncFunction } from './_tsup-dts-rollup.js';
+export { CreateMutateFunction } from './_tsup-dts-rollup.js';
+export { CreateMutationOptions } from './_tsup-dts-rollup.js';
+export { CreateMutationResult } from './_tsup-dts-rollup.js';
+export { CreateBaseMutationResult } from './_tsup-dts-rollup.js';
+export { CreateQueryOptions } from './_tsup-dts-rollup.js';
+export { CreateQueryResult } from './_tsup-dts-rollup.js';
+export { DefinedCreateBaseQueryResult } from './_tsup-dts-rollup.js';
+export { DefinedCreateInfiniteQueryResult } from './_tsup-dts-rollup.js';
+export { DefinedCreateQueryResult } from './_tsup-dts-rollup.js';
+export { QueryClient_alias_1 as QueryClient } from './_tsup-dts-rollup.js';
+export { QueryObserverOptions_alias_1 as QueryObserverOptions } from './_tsup-dts-rollup.js';
+export { DefaultOptions_alias_1 as DefaultOptions } from './_tsup-dts-rollup.js';
+export { QueryClientConfig_alias_1 as QueryClientConfig } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserverOptions_alias_1 as InfiniteQueryObserverOptions } from './_tsup-dts-rollup.js';
+export { useQuery } from './_tsup-dts-rollup.js';
+export { createQuery } from './_tsup-dts-rollup.js';
+export { queryOptions } from './_tsup-dts-rollup.js';
+export { DefinedInitialDataOptions } from './_tsup-dts-rollup.js';
+export { UndefinedInitialDataOptions } from './_tsup-dts-rollup.js';
+export { QueryClientContext_alias_1 as QueryClientContext } from './_tsup-dts-rollup.js';
+export { QueryClientProvider_alias_1 as QueryClientProvider } from './_tsup-dts-rollup.js';
+export { useQueryClient_alias_1 as useQueryClient } from './_tsup-dts-rollup.js';
+export { QueryClientProviderProps_alias_1 as QueryClientProviderProps } from './_tsup-dts-rollup.js';
+export { useIsFetching } from './_tsup-dts-rollup.js';
+export { createIsFetching } from './_tsup-dts-rollup.js';
+export { useInfiniteQuery } from './_tsup-dts-rollup.js';
+export { createInfiniteQuery } from './_tsup-dts-rollup.js';
+export { infiniteQueryOptions } from './_tsup-dts-rollup.js';
+export { DefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.js';
+export { UndefinedInitialDataInfiniteOptions } from './_tsup-dts-rollup.js';
+export { useMutation } from './_tsup-dts-rollup.js';
+export { mutationOptions } from './_tsup-dts-rollup.js';
+export { createMutation } from './_tsup-dts-rollup.js';
+export { useIsMutating } from './_tsup-dts-rollup.js';
+export { createIsMutating } from './_tsup-dts-rollup.js';
+export { useMutationState } from './_tsup-dts-rollup.js';
+export { createMutationState } from './_tsup-dts-rollup.js';
+export { useQueries } from './_tsup-dts-rollup.js';
+export { createQueries } from './_tsup-dts-rollup.js';
+export { useIsRestoring } from './_tsup-dts-rollup.js';
+export { IsRestoringProvider } from './_tsup-dts-rollup.js';
+export { focusManager } from './_tsup-dts-rollup.js';
+export { environmentManager } from './_tsup-dts-rollup.js';
+export { defaultShouldDehydrateMutation } from './_tsup-dts-rollup.js';
+export { defaultShouldDehydrateQuery } from './_tsup-dts-rollup.js';
+export { dehydrate } from './_tsup-dts-rollup.js';
+export { hydrate } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserver } from './_tsup-dts-rollup.js';
+export { MutationCache } from './_tsup-dts-rollup.js';
+export { MutationCacheNotifyEvent } from './_tsup-dts-rollup.js';
+export { MutationObserver } from './_tsup-dts-rollup.js';
+export { defaultScheduler } from './_tsup-dts-rollup.js';
+export { notifyManager } from './_tsup-dts-rollup.js';
+export { onlineManager } from './_tsup-dts-rollup.js';
+export { QueriesObserver } from './_tsup-dts-rollup.js';
+export { QueryCache } from './_tsup-dts-rollup.js';
+export { QueryCacheNotifyEvent } from './_tsup-dts-rollup.js';
+export { QueryObserver } from './_tsup-dts-rollup.js';
+export { CancelledError } from './_tsup-dts-rollup.js';
+export { isCancelledError } from './_tsup-dts-rollup.js';
+export { timeoutManager } from './_tsup-dts-rollup.js';
+export { ManagedTimerId } from './_tsup-dts-rollup.js';
+export { TimeoutCallback } from './_tsup-dts-rollup.js';
+export { TimeoutProvider } from './_tsup-dts-rollup.js';
+export { hashKey } from './_tsup-dts-rollup.js';
+export { isServer } from './_tsup-dts-rollup.js';
+export { keepPreviousData } from './_tsup-dts-rollup.js';
+export { matchMutation } from './_tsup-dts-rollup.js';
+export { matchQuery } from './_tsup-dts-rollup.js';
+export { noop } from './_tsup-dts-rollup.js';
+export { partialMatchKey } from './_tsup-dts-rollup.js';
+export { replaceEqualDeep } from './_tsup-dts-rollup.js';
+export { shouldThrowError } from './_tsup-dts-rollup.js';
+export { skipToken } from './_tsup-dts-rollup.js';
+export { MutationFilters } from './_tsup-dts-rollup.js';
+export { QueryFilters } from './_tsup-dts-rollup.js';
+export { SkipToken } from './_tsup-dts-rollup.js';
+export { Updater } from './_tsup-dts-rollup.js';
+export { experimental_streamedQuery } from './_tsup-dts-rollup.js';
+export { DehydratedState } from './_tsup-dts-rollup.js';
+export { DehydrateOptions } from './_tsup-dts-rollup.js';
+export { HydrateOptions } from './_tsup-dts-rollup.js';
+export { Mutation } from './_tsup-dts-rollup.js';
+export { MutationState } from './_tsup-dts-rollup.js';
+export { QueriesObserverOptions } from './_tsup-dts-rollup.js';
+export { Query } from './_tsup-dts-rollup.js';
+export { QueryState } from './_tsup-dts-rollup.js';
+export { NonUndefinedGuard } from './_tsup-dts-rollup.js';
+export { DistributiveOmit } from './_tsup-dts-rollup.js';
+export { OmitKeyof } from './_tsup-dts-rollup.js';
+export { Override } from './_tsup-dts-rollup.js';
+export { NoInfer } from './_tsup-dts-rollup.js';
+export { Register } from './_tsup-dts-rollup.js';
+export { DefaultError } from './_tsup-dts-rollup.js';
+export { QueryKey } from './_tsup-dts-rollup.js';
+export { dataTagSymbol } from './_tsup-dts-rollup.js';
+export { dataTagErrorSymbol } from './_tsup-dts-rollup.js';
+export { unsetMarker } from './_tsup-dts-rollup.js';
+export { UnsetMarker } from './_tsup-dts-rollup.js';
+export { AnyDataTag } from './_tsup-dts-rollup.js';
+export { DataTag } from './_tsup-dts-rollup.js';
+export { InferDataFromTag } from './_tsup-dts-rollup.js';
+export { InferErrorFromTag } from './_tsup-dts-rollup.js';
+export { QueryFunction } from './_tsup-dts-rollup.js';
+export { StaleTime } from './_tsup-dts-rollup.js';
+export { StaleTimeFunction } from './_tsup-dts-rollup.js';
+export { QueryBooleanOption } from './_tsup-dts-rollup.js';
+export { QueryPersister } from './_tsup-dts-rollup.js';
+export { QueryFunctionContext } from './_tsup-dts-rollup.js';
+export { InitialDataFunction } from './_tsup-dts-rollup.js';
+export { PlaceholderDataFunction } from './_tsup-dts-rollup.js';
+export { QueriesPlaceholderDataFunction } from './_tsup-dts-rollup.js';
+export { QueryKeyHashFunction } from './_tsup-dts-rollup.js';
+export { GetPreviousPageParamFunction } from './_tsup-dts-rollup.js';
+export { GetNextPageParamFunction } from './_tsup-dts-rollup.js';
+export { InfiniteData } from './_tsup-dts-rollup.js';
+export { QueryMeta } from './_tsup-dts-rollup.js';
+export { NetworkMode } from './_tsup-dts-rollup.js';
+export { NotifyOnChangeProps } from './_tsup-dts-rollup.js';
+export { QueryOptions } from './_tsup-dts-rollup.js';
+export { InitialPageParam } from './_tsup-dts-rollup.js';
+export { InfiniteQueryPageParamsOptions } from './_tsup-dts-rollup.js';
+export { ThrowOnError } from './_tsup-dts-rollup.js';
+export { WithRequired } from './_tsup-dts-rollup.js';
+export { DefaultedQueryObserverOptions } from './_tsup-dts-rollup.js';
+export { DefaultedInfiniteQueryObserverOptions } from './_tsup-dts-rollup.js';
+export { FetchQueryOptions } from './_tsup-dts-rollup.js';
+export { EnsureQueryDataOptions } from './_tsup-dts-rollup.js';
+export { EnsureInfiniteQueryDataOptions } from './_tsup-dts-rollup.js';
+export { FetchInfiniteQueryOptions } from './_tsup-dts-rollup.js';
+export { ResultOptions } from './_tsup-dts-rollup.js';
+export { RefetchOptions } from './_tsup-dts-rollup.js';
+export { InvalidateQueryFilters } from './_tsup-dts-rollup.js';
+export { RefetchQueryFilters } from './_tsup-dts-rollup.js';
+export { InvalidateOptions } from './_tsup-dts-rollup.js';
+export { ResetOptions } from './_tsup-dts-rollup.js';
+export { FetchNextPageOptions } from './_tsup-dts-rollup.js';
+export { FetchPreviousPageOptions } from './_tsup-dts-rollup.js';
+export { QueryStatus } from './_tsup-dts-rollup.js';
+export { FetchStatus } from './_tsup-dts-rollup.js';
+export { QueryObserverBaseResult } from './_tsup-dts-rollup.js';
+export { QueryObserverPendingResult } from './_tsup-dts-rollup.js';
+export { QueryObserverLoadingResult } from './_tsup-dts-rollup.js';
+export { QueryObserverLoadingErrorResult } from './_tsup-dts-rollup.js';
+export { QueryObserverRefetchErrorResult } from './_tsup-dts-rollup.js';
+export { QueryObserverSuccessResult } from './_tsup-dts-rollup.js';
+export { QueryObserverPlaceholderResult } from './_tsup-dts-rollup.js';
+export { DefinedQueryObserverResult } from './_tsup-dts-rollup.js';
+export { QueryObserverResult } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserverBaseResult } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserverPendingResult } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserverLoadingResult } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserverLoadingErrorResult } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserverRefetchErrorResult } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserverSuccessResult } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserverPlaceholderResult } from './_tsup-dts-rollup.js';
+export { DefinedInfiniteQueryObserverResult } from './_tsup-dts-rollup.js';
+export { InfiniteQueryObserverResult } from './_tsup-dts-rollup.js';
+export { MutationKey } from './_tsup-dts-rollup.js';
+export { MutationStatus } from './_tsup-dts-rollup.js';
+export { MutationScope } from './_tsup-dts-rollup.js';
+export { MutationMeta } from './_tsup-dts-rollup.js';
+export { MutationFunctionContext } from './_tsup-dts-rollup.js';
+export { MutationFunction } from './_tsup-dts-rollup.js';
+export { MutationOptions } from './_tsup-dts-rollup.js';
+export { MutationObserverOptions } from './_tsup-dts-rollup.js';
+export { MutateOptions } from './_tsup-dts-rollup.js';
+export { MutateFunction } from './_tsup-dts-rollup.js';
+export { MutationObserverBaseResult } from './_tsup-dts-rollup.js';
+export { MutationObserverIdleResult } from './_tsup-dts-rollup.js';
+export { MutationObserverLoadingResult } from './_tsup-dts-rollup.js';
+export { MutationObserverErrorResult } from './_tsup-dts-rollup.js';
+export { MutationObserverSuccessResult } from './_tsup-dts-rollup.js';
+export { MutationObserverResult } from './_tsup-dts-rollup.js';
+export { CancelOptions } from './_tsup-dts-rollup.js';
+export { SetDataOptions } from './_tsup-dts-rollup.js';
+export { NotifyEventType } from './_tsup-dts-rollup.js';
+export { NotifyEvent } from './_tsup-dts-rollup.js';

node_modules/@tanstack/solid-query/build/index.js

@@ -0,0 +1,521 @@
+import { MutationObserver, shouldThrowError, QueriesObserver, noop, QueryClient as QueryClient$1, replaceEqualDeep, hydrate, notifyManager, QueryObserver, InfiniteQueryObserver } from '@tanstack/query-core';
+export * from '@tanstack/query-core';
+import { createContext, useContext, createRenderEffect, onCleanup, createMemo, createComputed, on, mergeProps, createResource, batch, onMount, createSignal, createEffect } from 'solid-js';
+import { createComponent, isServer } from 'solid-js/web';
+import { createStore, unwrap, reconcile } from 'solid-js/store';
+
+// src/useQuery.ts
+var QueryClientContext = createContext(void 0);
+var useQueryClient = (queryClient) => {
+  if (queryClient) {
+    return queryClient;
+  }
+  const client = useContext(QueryClientContext);
+  if (!client) {
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  }
+  return client();
+};
+var QueryClientProvider = (props) => {
+  createRenderEffect((unmount) => {
+    unmount?.();
+    props.client.mount();
+    return props.client.unmount.bind(props.client);
+  });
+  onCleanup(() => props.client.unmount());
+  return createComponent(QueryClientContext.Provider, {
+    value: () => props.client,
+    get children() {
+      return props.children;
+    }
+  });
+};
+var IsRestoringContext = createContext(() => false);
+var useIsRestoring = () => useContext(IsRestoringContext);
+var IsRestoringProvider = IsRestoringContext.Provider;
+
+// src/useBaseQuery.ts
+function reconcileFn(store, result, reconcileOption, queryHash) {
+  if (reconcileOption === false) return result;
+  if (typeof reconcileOption === "function") {
+    const newData2 = reconcileOption(store.data, result.data);
+    return { ...result, data: newData2 };
+  }
+  let data = result.data;
+  if (store.data === void 0) {
+    try {
+      data = structuredClone(data);
+    } catch (error) {
+    }
+  }
+  const newData = reconcile(data, { key: reconcileOption })(store.data);
+  return { ...result, data: newData };
+}
+var hydratableObserverResult = (query, result) => {
+  if (!isServer) return result;
+  const obj = {
+    ...unwrap(result),
+    // During SSR, functions cannot be serialized, so we need to remove them
+    // This is safe because we will add these functions back when the query is hydrated
+    refetch: void 0
+  };
+  if ("fetchNextPage" in result) {
+    obj.fetchNextPage = void 0;
+    obj.fetchPreviousPage = void 0;
+  }
+  obj.hydrationData = {
+    state: query.state,
+    queryKey: query.queryKey,
+    queryHash: query.queryHash,
+    ...query.meta && { meta: query.meta }
+  };
+  return obj;
+};
+function useBaseQuery(options, Observer, queryClient) {
+  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const isRestoring = useIsRestoring();
+  let unsubscribeQueued = false;
+  const defaultedOptions = createMemo(() => {
+    const defaultOptions = client().defaultQueryOptions(options());
+    defaultOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
+    defaultOptions.structuralSharing = false;
+    if (isServer) {
+      defaultOptions.retry = false;
+      defaultOptions.throwOnError = true;
+      defaultOptions.experimental_prefetchInRender = true;
+    }
+    return defaultOptions;
+  });
+  const initialOptions = defaultedOptions();
+  const [observer, setObserver] = createSignal(
+    new Observer(client(), defaultedOptions())
+  );
+  let observerResult = observer().getOptimisticResult(defaultedOptions());
+  const [state, setState] = createStore(observerResult);
+  const createServerSubscriber = (resolve, reject) => {
+    return observer().subscribe((result) => {
+      notifyManager.batchCalls(() => {
+        const query = observer().getCurrentQuery();
+        const unwrappedResult = hydratableObserverResult(query, result);
+        if (result.data !== void 0 && unwrappedResult.isError) {
+          reject(unwrappedResult.error);
+          unsubscribeIfQueued();
+        } else {
+          resolve(unwrappedResult);
+          unsubscribeIfQueued();
+        }
+      })();
+    });
+  };
+  const unsubscribeIfQueued = () => {
+    if (unsubscribeQueued) {
+      unsubscribe?.();
+      unsubscribeQueued = false;
+    }
+  };
+  const createClientSubscriber = () => {
+    const obs = observer();
+    return obs.subscribe((result) => {
+      observerResult = result;
+      queueMicrotask(() => {
+        if (unsubscribe) {
+          refetch();
+        }
+      });
+    });
+  };
+  function setStateWithReconciliation(res) {
+    const opts = observer().options;
+    const reconcileOptions = opts.reconcile;
+    setState((store) => {
+      return reconcileFn(
+        store,
+        res,
+        reconcileOptions === void 0 ? false : reconcileOptions,
+        opts.queryHash
+      );
+    });
+  }
+  function createDeepSignal() {
+    return [
+      () => state,
+      (v) => {
+        const unwrapped = unwrap(state);
+        if (typeof v === "function") {
+          v = v(unwrapped);
+        }
+        if (v?.hydrationData) {
+          const { hydrationData, ...rest } = v;
+          v = rest;
+        }
+        setStateWithReconciliation(v);
+      }
+    ];
+  }
+  let unsubscribe = null;
+  let resolver = null;
+  const [queryResource, { refetch }] = createResource(
+    () => {
+      const obs = observer();
+      return new Promise((resolve, reject) => {
+        resolver = resolve;
+        if (isServer) {
+          unsubscribe = createServerSubscriber(resolve, reject);
+        } else if (!unsubscribe && !isRestoring()) {
+          unsubscribe = createClientSubscriber();
+        }
+        obs.updateResult();
+        if (observerResult.isError && !observerResult.isFetching && !isRestoring() && shouldThrowError(obs.options.throwOnError, [
+          observerResult.error,
+          obs.getCurrentQuery()
+        ])) {
+          setStateWithReconciliation(observerResult);
+          return reject(observerResult.error);
+        }
+        if (!observerResult.isLoading) {
+          resolver = null;
+          return resolve(
+            hydratableObserverResult(obs.getCurrentQuery(), observerResult)
+          );
+        }
+        setStateWithReconciliation(observerResult);
+      });
+    },
+    {
+      storage: createDeepSignal,
+      get deferStream() {
+        return options().deferStream;
+      },
+      /**
+       * If this resource was populated on the server (either sync render, or streamed in over time), onHydrated
+       * will be called. This is the point at which we can hydrate the query cache state, and setup the query subscriber.
+       *
+       * Leveraging onHydrated allows us to plug into the async and streaming support that solidjs resources already support.
+       *
+       * Note that this is only invoked on the client, for queries that were originally run on the server.
+       */
+      onHydrated(_k, info) {
+        if (info.value && "hydrationData" in info.value) {
+          hydrate(client(), {
+            // @ts-expect-error - hydrationData is not correctly typed internally
+            queries: [{ ...info.value.hydrationData }]
+          });
+        }
+        if (unsubscribe) return;
+        const newOptions = { ...initialOptions };
+        if ((initialOptions.staleTime || !initialOptions.initialData) && info.value) {
+          newOptions.refetchOnMount = false;
+        }
+        observer().setOptions(newOptions);
+        setStateWithReconciliation(observer().getOptimisticResult(newOptions));
+        unsubscribe = createClientSubscriber();
+      }
+    }
+  );
+  createComputed(
+    on(
+      client,
+      (c) => {
+        if (unsubscribe) {
+          unsubscribe();
+        }
+        const newObserver = new Observer(c, defaultedOptions());
+        unsubscribe = createClientSubscriber();
+        setObserver(newObserver);
+      },
+      {
+        defer: true
+      }
+    )
+  );
+  createComputed(
+    on(
+      isRestoring,
+      (restoring) => {
+        if (!restoring && !isServer) {
+          refetch();
+        }
+      },
+      { defer: true }
+    )
+  );
+  onCleanup(() => {
+    if (isServer && queryResource.loading) {
+      unsubscribeQueued = true;
+      return;
+    }
+    if (unsubscribe) {
+      unsubscribe();
+      unsubscribe = null;
+    }
+    if (resolver && !isServer) {
+      resolver(observerResult);
+      resolver = null;
+    }
+  });
+  createComputed(
+    on(
+      [observer, defaultedOptions],
+      ([obs, opts]) => {
+        obs.setOptions(opts);
+        setStateWithReconciliation(obs.getOptimisticResult(opts));
+        refetch();
+      },
+      { defer: true }
+    )
+  );
+  const handler = {
+    get(target, prop) {
+      if (prop === "data") {
+        if (state.data !== void 0) {
+          return queryResource.latest?.data;
+        }
+        return queryResource()?.data;
+      }
+      return Reflect.get(target, prop);
+    }
+  };
+  return new Proxy(state, handler);
+}
+
+// src/useQuery.ts
+function useQuery(options, queryClient) {
+  return useBaseQuery(
+    createMemo(() => options()),
+    QueryObserver,
+    queryClient
+  );
+}
+function useInfiniteQuery(options, queryClient) {
+  return useBaseQuery(
+    createMemo(() => options()),
+    InfiniteQueryObserver,
+    queryClient
+  );
+}
+function useMutation(options, queryClient) {
+  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const observer = new MutationObserver(client(), options());
+  const mutate = (variables, mutateOptions) => {
+    observer.mutate(variables, mutateOptions).catch(noop);
+  };
+  const [state, setState] = createStore({
+    ...observer.getCurrentResult(),
+    mutate,
+    mutateAsync: observer.getCurrentResult().mutate
+  });
+  createComputed(() => {
+    observer.setOptions(options());
+  });
+  createComputed(
+    on(
+      () => state.status,
+      () => {
+        if (state.isError && shouldThrowError(observer.options.throwOnError, [state.error])) {
+          throw state.error;
+        }
+      }
+    )
+  );
+  const unsubscribe = observer.subscribe((result) => {
+    setState({
+      ...result,
+      mutate,
+      mutateAsync: result.mutate
+    });
+  });
+  onCleanup(unsubscribe);
+  return state;
+}
+function useQueries(queriesOptions, queryClient) {
+  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const isRestoring = useIsRestoring();
+  const defaultedQueries = createMemo(
+    () => queriesOptions().queries.map(
+      (options) => mergeProps(
+        client().defaultQueryOptions(options),
+        {
+          get _optimisticResults() {
+            return isRestoring() ? "isRestoring" : "optimistic";
+          }
+        }
+      )
+    )
+  );
+  const observer = new QueriesObserver(
+    client(),
+    defaultedQueries(),
+    queriesOptions().combine ? {
+      combine: queriesOptions().combine
+    } : void 0
+  );
+  const [state, setState] = createStore(
+    observer.getOptimisticResult(
+      defaultedQueries(),
+      queriesOptions().combine
+    )[1]()
+  );
+  createRenderEffect(
+    on(
+      () => queriesOptions().queries.length,
+      () => setState(
+        observer.getOptimisticResult(
+          defaultedQueries(),
+          queriesOptions().combine
+        )[1]()
+      )
+    )
+  );
+  const dataResources = createMemo(
+    on(
+      () => state.length,
+      () => state.map((queryRes) => {
+        const dataPromise = () => new Promise((resolve) => {
+          if (queryRes.isFetching && queryRes.isLoading) return;
+          resolve(unwrap(queryRes.data));
+        });
+        return createResource(dataPromise);
+      })
+    )
+  );
+  batch(() => {
+    const dataResources_ = dataResources();
+    for (let index = 0; index < dataResources_.length; index++) {
+      const dataResource = dataResources_[index];
+      dataResource[1].mutate(() => unwrap(state[index].data));
+      dataResource[1].refetch();
+    }
+  });
+  let taskQueue = [];
+  const subscribeToObserver = () => observer.subscribe((result) => {
+    taskQueue.push(() => {
+      batch(() => {
+        const dataResources_ = dataResources();
+        for (let index = 0; index < dataResources_.length; index++) {
+          const dataResource = dataResources_[index];
+          const unwrappedResult = { ...unwrap(result[index]) };
+          setState(index, unwrap(unwrappedResult));
+          dataResource[1].mutate(() => unwrap(state[index].data));
+          dataResource[1].refetch();
+        }
+      });
+    });
+    queueMicrotask(() => {
+      const taskToRun = taskQueue.pop();
+      if (taskToRun) taskToRun();
+      taskQueue = [];
+    });
+  });
+  let unsubscribe = noop;
+  createComputed((cleanup) => {
+    cleanup?.();
+    unsubscribe = isRestoring() ? noop : subscribeToObserver();
+    return () => queueMicrotask(unsubscribe);
+  });
+  onCleanup(unsubscribe);
+  onMount(() => {
+    observer.setQueries(
+      defaultedQueries(),
+      queriesOptions().combine ? {
+        combine: queriesOptions().combine
+      } : void 0
+    );
+  });
+  createComputed(() => {
+    observer.setQueries(
+      defaultedQueries(),
+      queriesOptions().combine ? {
+        combine: queriesOptions().combine
+      } : void 0
+    );
+  });
+  const handler = (index) => ({
+    get(target, prop) {
+      if (prop === "data") {
+        return dataResources()[index][0]();
+      }
+      return Reflect.get(target, prop);
+    }
+  });
+  const getProxies = () => state.map((s, index) => {
+    return new Proxy(s, handler(index));
+  });
+  const [proxyState, setProxyState] = createStore(getProxies());
+  createRenderEffect(() => setProxyState(getProxies()));
+  return proxyState;
+}
+var QueryClient = class extends QueryClient$1 {
+  constructor(config = {}) {
+    super(config);
+  }
+};
+
+// src/queryOptions.ts
+function queryOptions(options) {
+  return options;
+}
+function useIsFetching(filters, queryClient) {
+  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const queryCache = createMemo(() => client().getQueryCache());
+  const [fetches, setFetches] = createSignal(client().isFetching(filters?.()));
+  const unsubscribe = queryCache().subscribe(() => {
+    setFetches(client().isFetching(filters?.()));
+  });
+  onCleanup(unsubscribe);
+  return fetches;
+}
+
+// src/infiniteQueryOptions.ts
+function infiniteQueryOptions(options) {
+  return options;
+}
+
+// src/mutationOptions.ts
+function mutationOptions(options) {
+  return options;
+}
+function useIsMutating(filters, queryClient) {
+  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const mutationCache = createMemo(() => client().getMutationCache());
+  const [mutations, setMutations] = createSignal(
+    client().isMutating(filters?.())
+  );
+  const unsubscribe = mutationCache().subscribe((_result) => {
+    setMutations(client().isMutating(filters?.()));
+  });
+  onCleanup(unsubscribe);
+  return mutations;
+}
+function getResult(mutationCache, options) {
+  return mutationCache.findAll(options.filters).map(
+    (mutation) => options.select ? options.select(mutation) : mutation.state
+  );
+}
+function useMutationState(options = () => ({}), queryClient) {
+  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const mutationCache = createMemo(() => client().getMutationCache());
+  const [result, setResult] = createSignal(
+    getResult(mutationCache(), options())
+  );
+  createEffect(() => {
+    const unsubscribe = mutationCache().subscribe(() => {
+      const nextResult = replaceEqualDeep(
+        result(),
+        getResult(mutationCache(), options())
+      );
+      if (result() !== nextResult) {
+        setResult(nextResult);
+      }
+    });
+    onCleanup(unsubscribe);
+  });
+  return result;
+}
+
+// src/index.ts
+var createQuery = useQuery;
+var createInfiniteQuery = useInfiniteQuery;
+var createMutation = useMutation;
+var createQueries = useQueries;
+
+export { IsRestoringProvider, QueryClient, QueryClientContext, QueryClientProvider, createInfiniteQuery, useIsFetching as createIsFetching, useIsMutating as createIsMutating, createMutation, useMutationState as createMutationState, createQueries, createQuery, infiniteQueryOptions, mutationOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, useQueries, useQuery, useQueryClient };

node_modules/@tanstack/solid-query/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@tanstack/solid-query",
+  "version": "5.100.1",
+  "description": "Primitives for managing, caching and syncing asynchronous and remote data in Solid",
+  "author": "tannerlinsley",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TanStack/query.git",
+    "directory": "packages/solid-query"
+  },
+  "homepage": "https://tanstack.com/query",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/tannerlinsley"
+  },
+  "type": "module",
+  "main": "./build/index.cjs",
+  "module": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "browser": {},
+  "exports": {
+    "@tanstack/custom-condition": "./src/index.ts",
+    "development": {
+      "import": {
+        "types": "./build/index.d.ts",
+        "default": "./build/dev.js"
+      },
+      "require": {
+        "types": "./build/index.d.cts",
+        "default": "./build/dev.cjs"
+      }
+    },
+    "import": {
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    },
+    "require": {
+      "types": "./build/index.d.cts",
+      "default": "./build/index.cjs"
+    }
+  },
+  "files": [
+    "build",
+    "src",
+    "!src/__tests__"
+  ],
+  "dependencies": {
+    "@tanstack/query-core": "5.100.1"
+  },
+  "devDependencies": {
+    "@solidjs/testing-library": "^0.8.10",
+    "npm-run-all2": "^5.0.0",
+    "solid-js": "^1.9.7",
+    "tsup-preset-solid": "^2.2.0",
+    "vite-plugin-solid": "^2.11.6",
+    "@tanstack/query-test-utils": "0.0.0"
+  },
+  "peerDependencies": {
+    "solid-js": "^1.6.0"
+  },
+  "scripts": {
+    "clean": "premove ./build ./coverage ./dist-ts",
+    "compile": "tsc --build",
+    "test:eslint": "eslint --concurrency=auto ./src",
+    "test:types": "npm-run-all --serial test:types:*",
+    "test:types:ts54": "node ../../node_modules/typescript54/lib/tsc.js --build tsconfig.legacy.json",
+    "test:types:ts55": "node ../../node_modules/typescript55/lib/tsc.js --build tsconfig.legacy.json",
+    "test:types:ts56": "node ../../node_modules/typescript56/lib/tsc.js --build tsconfig.legacy.json",
+    "test:types:ts57": "node ../../node_modules/typescript57/lib/tsc.js --build tsconfig.legacy.json",
+    "test:types:ts58": "node ../../node_modules/typescript58/lib/tsc.js --build tsconfig.legacy.json",
+    "test:types:ts59": "node ../../node_modules/typescript59/lib/tsc.js --build tsconfig.legacy.json",
+    "test:types:tscurrent": "tsc --build",
+    "test:types:ts60": "node ../../node_modules/typescript60/lib/tsc.js --build tsconfig.legacy.json",
+    "test:lib": "vitest --retry=3",
+    "test:lib:dev": "pnpm run test:lib --watch",
+    "test:build": "publint --strict && attw --pack",
+    "build": "tsup --tsconfig tsconfig.prod.json",
+    "build:watch": "tsup --watch"
+  }
+}

node_modules/@tanstack/solid-query/src/QueryClient.ts

@@ -0,0 +1,84 @@
+import { QueryClient as QueryCoreClient } from '@tanstack/query-core'
+import type {
+  DefaultOptions as CoreDefaultOptions,
+  DefaultError,
+  OmitKeyof,
+  QueryClientConfig as QueryCoreClientConfig,
+  InfiniteQueryObserverOptions as QueryCoreInfiniteQueryObserverOptions,
+  QueryObserverOptions as QueryCoreObserverOptions,
+  QueryKey,
+} from '@tanstack/query-core'
+
+export interface QueryObserverOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = never,
+> extends OmitKeyof<
+  QueryCoreObserverOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryData,
+    TQueryKey,
+    TPageParam
+  >,
+  'structuralSharing'
+> {
+  /**
+   * Set this to a reconciliation key to enable reconciliation between query results.
+   * Set this to `false` to disable reconciliation between query results.
+   * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+   * Defaults reconciliation to false.
+   */
+  reconcile?:
+    | string
+    | false
+    | ((oldData: TData | undefined, newData: TData) => TData)
+}
+
+export interface InfiniteQueryObserverOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
+> extends OmitKeyof<
+  QueryCoreInfiniteQueryObserverOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryKey,
+    TPageParam
+  >,
+  'structuralSharing'
+> {
+  /**
+   * Set this to a reconciliation key to enable reconciliation between query results.
+   * Set this to `false` to disable reconciliation between query results.
+   * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+   * Defaults reconciliation to false.
+   */
+  reconcile?:
+    | string
+    | false
+    | ((oldData: TData | undefined, newData: TData) => TData)
+}
+
+export interface DefaultOptions<
+  TError = DefaultError,
+> extends CoreDefaultOptions<TError> {
+  queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'queryKey'>
+}
+
+export interface QueryClientConfig extends QueryCoreClientConfig {
+  defaultOptions?: DefaultOptions
+}
+
+export class QueryClient extends QueryCoreClient {
+  constructor(config: QueryClientConfig = {}) {
+    super(config)
+  }
+}

node_modules/@tanstack/solid-query/src/QueryClientProvider.tsx

@@ -0,0 +1,47 @@
+import {
+  createContext,
+  createRenderEffect,
+  onCleanup,
+  useContext,
+} from 'solid-js'
+import type { QueryClient } from './QueryClient'
+import type { JSX } from 'solid-js'
+
+export const QueryClientContext = createContext<
+  (() => QueryClient) | undefined
+>(undefined)
+
+export const useQueryClient = (queryClient?: QueryClient) => {
+  if (queryClient) {
+    return queryClient
+  }
+  const client = useContext(QueryClientContext)
+
+  if (!client) {
+    throw new Error('No QueryClient set, use QueryClientProvider to set one')
+  }
+
+  return client()
+}
+
+export type QueryClientProviderProps = {
+  client: QueryClient
+  children?: JSX.Element
+}
+
+export const QueryClientProvider = (
+  props: QueryClientProviderProps,
+): JSX.Element => {
+  createRenderEffect<() => void>((unmount) => {
+    unmount?.()
+    props.client.mount()
+    return props.client.unmount.bind(props.client)
+  })
+  onCleanup(() => props.client.unmount())
+
+  return (
+    <QueryClientContext.Provider value={() => props.client}>
+      {props.children}
+    </QueryClientContext.Provider>
+  )
+}

node_modules/@tanstack/solid-query/src/index.ts

@@ -0,0 +1,87 @@
+/* istanbul ignore file */
+
+import { useQuery } from './useQuery'
+import { useInfiniteQuery } from './useInfiniteQuery'
+import { useMutation } from './useMutation'
+import { useQueries } from './useQueries'
+
+// Re-export core
+export * from '@tanstack/query-core'
+
+// Solid Query
+export * from './types'
+
+export type {
+  DefinedUseBaseQueryResult,
+  DefinedUseInfiniteQueryResult,
+  DefinedUseQueryResult,
+  SolidInfiniteQueryOptions,
+  SolidMutationOptions,
+  SolidQueryOptions,
+  UseBaseMutationResult,
+  UseBaseQueryOptions,
+  UseBaseQueryResult,
+  UseInfiniteQueryOptions,
+  UseInfiniteQueryResult,
+  UseMutateAsyncFunction,
+  UseMutateFunction,
+  UseMutationOptions,
+  UseMutationResult,
+  UseQueryOptions,
+  UseQueryResult,
+  // Aliases (create* and use* are both supported)
+  UseBaseQueryOptions as CreateBaseQueryOptions,
+  UseBaseQueryResult as CreateBaseQueryResult,
+  UseInfiniteQueryOptions as CreateInfiniteQueryOptions,
+  UseInfiniteQueryResult as CreateInfiniteQueryResult,
+  UseMutateAsyncFunction as CreateMutateAsyncFunction,
+  UseMutateFunction as CreateMutateFunction,
+  UseMutationOptions as CreateMutationOptions,
+  UseMutationResult as CreateMutationResult,
+  UseBaseMutationResult as CreateBaseMutationResult,
+  UseQueryOptions as CreateQueryOptions,
+  UseQueryResult as CreateQueryResult,
+  DefinedUseBaseQueryResult as DefinedCreateBaseQueryResult,
+  DefinedUseInfiniteQueryResult as DefinedCreateInfiniteQueryResult,
+  DefinedUseQueryResult as DefinedCreateQueryResult,
+} from './types'
+
+export { QueryClient } from './QueryClient'
+export type {
+  QueryObserverOptions,
+  DefaultOptions,
+  QueryClientConfig,
+  InfiniteQueryObserverOptions,
+} from './QueryClient'
+export { useQuery } from './useQuery'
+export const createQuery = useQuery
+export { queryOptions } from './queryOptions'
+export type {
+  DefinedInitialDataOptions,
+  UndefinedInitialDataOptions,
+} from './queryOptions'
+export {
+  QueryClientContext,
+  QueryClientProvider,
+  useQueryClient,
+} from './QueryClientProvider'
+export type { QueryClientProviderProps } from './QueryClientProvider'
+export { useIsFetching } from './useIsFetching'
+export { useIsFetching as createIsFetching } from './useIsFetching'
+export { useInfiniteQuery }
+export const createInfiniteQuery = useInfiniteQuery
+export { infiniteQueryOptions } from './infiniteQueryOptions'
+export type {
+  DefinedInitialDataInfiniteOptions,
+  UndefinedInitialDataInfiniteOptions,
+} from './infiniteQueryOptions'
+export { useMutation } from './useMutation'
+export { mutationOptions } from './mutationOptions'
+export const createMutation = useMutation
+export { useIsMutating } from './useIsMutating'
+export { useIsMutating as createIsMutating } from './useIsMutating'
+export { useMutationState } from './useMutationState'
+export { useMutationState as createMutationState } from './useMutationState'
+export { useQueries } from './useQueries'
+export const createQueries = useQueries
+export { useIsRestoring, IsRestoringProvider } from './isRestoring'

node_modules/@tanstack/solid-query/src/infiniteQueryOptions.ts

@@ -0,0 +1,106 @@
+import type {
+  DataTag,
+  DefaultError,
+  InfiniteData,
+  NonUndefinedGuard,
+  QueryKey,
+} from '@tanstack/query-core'
+import type { SolidInfiniteQueryOptions } from './types'
+import type { Accessor } from 'solid-js'
+
+export type UndefinedInitialDataInfiniteOptions<
+  TQueryFnData,
+  TError = DefaultError,
+  TData = InfiniteData<TQueryFnData>,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
+> = Accessor<
+  SolidInfiniteQueryOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryKey,
+    TPageParam
+  > & {
+    initialData?: undefined
+  }
+>
+
+export type DefinedInitialDataInfiniteOptions<
+  TQueryFnData,
+  TError = DefaultError,
+  // should we handle page param correctly
+  TData = InfiniteData<TQueryFnData>,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
+> = Accessor<
+  SolidInfiniteQueryOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryKey,
+    TPageParam
+  > & {
+    initialData:
+      | NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>
+      | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>)
+  }
+>
+export function infiniteQueryOptions<
+  TQueryFnData,
+  TError = DefaultError,
+  TData = InfiniteData<TQueryFnData>,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
+>(
+  options: ReturnType<
+    DefinedInitialDataInfiniteOptions<
+      TQueryFnData,
+      TError,
+      TData,
+      TQueryKey,
+      TPageParam
+    >
+  >,
+): ReturnType<
+  DefinedInitialDataInfiniteOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryKey,
+    TPageParam
+  >
+> & {
+  queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>
+}
+export function infiniteQueryOptions<
+  TQueryFnData,
+  TError = DefaultError,
+  TData = InfiniteData<TQueryFnData>,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
+>(
+  options: ReturnType<
+    UndefinedInitialDataInfiniteOptions<
+      TQueryFnData,
+      TError,
+      TData,
+      TQueryKey,
+      TPageParam
+    >
+  >,
+): ReturnType<
+  UndefinedInitialDataInfiniteOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryKey,
+    TPageParam
+  >
+> & {
+  queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>
+}
+
+export function infiniteQueryOptions(options: unknown) {
+  return options
+}

node_modules/@tanstack/solid-query/src/isRestoring.ts

@@ -0,0 +1,7 @@
+import { createContext, useContext } from 'solid-js'
+import type { Accessor } from 'solid-js'
+
+const IsRestoringContext = createContext<Accessor<boolean>>(() => false)
+
+export const useIsRestoring = () => useContext(IsRestoringContext)
+export const IsRestoringProvider = IsRestoringContext.Provider

node_modules/@tanstack/solid-query/src/mutationOptions.ts

@@ -0,0 +1,41 @@
+import type { DefaultError, WithRequired } from '@tanstack/query-core'
+import type { SolidMutationOptions } from './types'
+
+export function mutationOptions<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = void,
+  TOnMutateResult = unknown,
+>(
+  options: WithRequired<
+    SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>,
+    'mutationKey'
+  >,
+): WithRequired<
+  SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>,
+  'mutationKey'
+>
+export function mutationOptions<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = void,
+  TOnMutateResult = unknown,
+>(
+  options: Omit<
+    SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>,
+    'mutationKey'
+  >,
+): Omit<
+  SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>,
+  'mutationKey'
+>
+export function mutationOptions<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = void,
+  TOnMutateResult = unknown,
+>(
+  options: SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>,
+): SolidMutationOptions<TData, TError, TVariables, TOnMutateResult> {
+  return options
+}

node_modules/@tanstack/solid-query/src/queryOptions.ts

@@ -0,0 +1,59 @@
+import type { DataTag, DefaultError, QueryKey } from '@tanstack/query-core'
+import type { SolidQueryOptions } from './types'
+import type { Accessor } from 'solid-js'
+
+export type UndefinedInitialDataOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> = Accessor<
+  SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    initialData?: undefined
+  }
+>
+
+export type DefinedInitialDataOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> = Accessor<
+  SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    initialData: TQueryFnData | (() => TQueryFnData)
+  }
+>
+
+export function queryOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+>(
+  options: ReturnType<
+    UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>
+  >,
+): ReturnType<
+  UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>
+> & {
+  queryKey: DataTag<TQueryKey, TQueryFnData, TError>
+}
+
+export function queryOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+>(
+  options: ReturnType<
+    DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>
+  >,
+): ReturnType<
+  DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>
+> & {
+  queryKey: DataTag<TQueryKey, TQueryFnData, TError>
+}
+
+export function queryOptions(options: unknown) {
+  return options
+}

node_modules/@tanstack/solid-query/src/types.ts

@@ -0,0 +1,200 @@
+/* istanbul ignore file */
+
+import type {
+  DefaultError,
+  DefinedInfiniteQueryObserverResult,
+  DefinedQueryObserverResult,
+  InfiniteQueryObserverResult,
+  MutateFunction,
+  MutationObserverOptions,
+  MutationObserverResult,
+  OmitKeyof,
+  Override,
+  QueryKey,
+  QueryObserverResult,
+} from '@tanstack/query-core'
+import type {
+  InfiniteQueryObserverOptions,
+  QueryObserverOptions,
+} from './QueryClient'
+import type { Accessor } from 'solid-js'
+
+export interface UseBaseQueryOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> extends OmitKeyof<
+  QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>,
+  'suspense'
+> {
+  /**
+   * Only applicable while rendering queries on the server with streaming.
+   * Set `deferStream` to `true` to wait for the query to resolve on the server before flushing the stream.
+   * This can be useful to avoid sending a loading state to the client before the query has resolved.
+   * Defaults to `false`.
+   */
+  deferStream?: boolean
+  /**
+   * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
+   * The `data` property on useQuery is a SolidJS resource and will automatically suspend when the data is loading.
+   * Setting `suspense` to `false` will be a no-op.
+   */
+  suspense?: boolean
+}
+
+export interface SolidQueryOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> extends UseBaseQueryOptions<
+  TQueryFnData,
+  TError,
+  TData,
+  TQueryFnData,
+  TQueryKey
+> {}
+
+export type UseQueryOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>>
+
+/* --- Create Query and Create Base Query  Types --- */
+
+export type UseBaseQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+> = QueryObserverResult<TData, TError>
+
+export type UseQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+> = UseBaseQueryResult<TData, TError>
+
+export type DefinedUseBaseQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+> = DefinedQueryObserverResult<TData, TError>
+
+export type DefinedUseQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+> = DefinedUseBaseQueryResult<TData, TError>
+
+/* --- Create Infinite Queries Types --- */
+export interface SolidInfiniteQueryOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
+> extends OmitKeyof<
+  InfiniteQueryObserverOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryKey,
+    TPageParam
+  >,
+  'queryKey' | 'suspense'
+> {
+  queryKey: TQueryKey
+  /**
+   * Only applicable while rendering queries on the server with streaming.
+   * Set `deferStream` to `true` to wait for the query to resolve on the server before flushing the stream.
+   * This can be useful to avoid sending a loading state to the client before the query has resolved.
+   * Defaults to `false`.
+   */
+  deferStream?: boolean
+  /**
+   * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
+   * The `data` property on useInfiniteQuery is a SolidJS resource and will automatically suspend when the data is loading.
+   * Setting `suspense` to `false` will be a no-op.
+   */
+  suspense?: boolean
+}
+
+export type UseInfiniteQueryOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
+> = Accessor<
+  SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>
+>
+
+export type UseInfiniteQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+> = InfiniteQueryObserverResult<TData, TError>
+
+export type DefinedUseInfiniteQueryResult<
+  TData = unknown,
+  TError = DefaultError,
+> = DefinedInfiniteQueryObserverResult<TData, TError>
+
+/* --- Create Mutation Types --- */
+export interface SolidMutationOptions<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = void,
+  TOnMutateResult = unknown,
+> extends OmitKeyof<
+  MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>,
+  '_defaulted'
+> {}
+
+export type UseMutationOptions<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = void,
+  TOnMutateResult = unknown,
+> = Accessor<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>>
+
+export type UseMutateFunction<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = void,
+  TOnMutateResult = unknown,
+> = (
+  ...args: Parameters<
+    MutateFunction<TData, TError, TVariables, TOnMutateResult>
+  >
+) => void
+
+export type UseMutateAsyncFunction<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = void,
+  TOnMutateResult = unknown,
+> = MutateFunction<TData, TError, TVariables, TOnMutateResult>
+
+export type UseBaseMutationResult<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TOnMutateResult = unknown,
+> = Override<
+  MutationObserverResult<TData, TError, TVariables, TOnMutateResult>,
+  { mutate: UseMutateFunction<TData, TError, TVariables, TOnMutateResult> }
+> & {
+  mutateAsync: UseMutateAsyncFunction<
+    TData,
+    TError,
+    TVariables,
+    TOnMutateResult
+  >
+}
+
+export type UseMutationResult<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TOnMutateResult = unknown,
+> = UseBaseMutationResult<TData, TError, TVariables, TOnMutateResult>

node_modules/@tanstack/solid-query/src/useBaseQuery.ts

@@ -0,0 +1,389 @@
+// Had to disable the lint rule because isServer type is defined as false
+// in solid-js/web package. I'll create a GitHub issue with them to see
+// why that happens.
+import { hydrate, notifyManager, shouldThrowError } from '@tanstack/query-core'
+import { isServer } from 'solid-js/web'
+import {
+  createComputed,
+  createMemo,
+  createResource,
+  createSignal,
+  on,
+  onCleanup,
+} from 'solid-js'
+import { createStore, reconcile, unwrap } from 'solid-js/store'
+import { useQueryClient } from './QueryClientProvider'
+import { useIsRestoring } from './isRestoring'
+import type { UseBaseQueryOptions } from './types'
+import type { Accessor, Signal } from 'solid-js'
+import type { QueryClient } from './QueryClient'
+import type {
+  Query,
+  QueryKey,
+  QueryObserver,
+  QueryObserverResult,
+} from '@tanstack/query-core'
+
+function reconcileFn<TData, TError>(
+  store: QueryObserverResult<TData, TError>,
+  result: QueryObserverResult<TData, TError>,
+  reconcileOption:
+    | string
+    | false
+    | ((oldData: TData | undefined, newData: TData) => TData),
+  queryHash?: string,
+): QueryObserverResult<TData, TError> {
+  if (reconcileOption === false) return result
+  if (typeof reconcileOption === 'function') {
+    const newData = reconcileOption(store.data, result.data as TData)
+    return { ...result, data: newData } as typeof result
+  }
+  let data = result.data
+  if (store.data === undefined) {
+    try {
+      data = structuredClone(data)
+    } catch (error) {
+      if (process.env.NODE_ENV !== 'production') {
+        if (error instanceof Error) {
+          console.warn(
+            `Unable to correctly reconcile data for query key: ${queryHash}. ` +
+              `Possibly because the query data contains data structures that aren't supported ` +
+              `by the 'structuredClone' algorithm. Consider using a callback function instead ` +
+              `to manage the reconciliation manually.\n\n Error Received: ${error.name} - ${error.message}`,
+          )
+        }
+      }
+    }
+  }
+  const newData = reconcile(data, { key: reconcileOption })(store.data)
+  return { ...result, data: newData } as typeof result
+}
+
+/**
+ * Solid's `onHydrated` functionality will silently "fail" (hydrate with an empty object)
+ * if the resource data is not serializable.
+ */
+const hydratableObserverResult = <
+  TQueryFnData,
+  TError,
+  TData,
+  TQueryKey extends QueryKey,
+  TDataHydratable,
+>(
+  query: Query<TQueryFnData, TError, TData, TQueryKey>,
+  result: QueryObserverResult<TDataHydratable, TError>,
+) => {
+  if (!isServer) return result
+  const obj: any = {
+    ...unwrap(result),
+    // During SSR, functions cannot be serialized, so we need to remove them
+    // This is safe because we will add these functions back when the query is hydrated
+    refetch: undefined,
+  }
+
+  // If the query is an infinite query, we need to remove additional properties
+  if ('fetchNextPage' in result) {
+    obj.fetchNextPage = undefined
+    obj.fetchPreviousPage = undefined
+  }
+
+  // We will also attach the dehydrated state of the query to the result
+  // This will be removed on client after hydration
+  obj.hydrationData = {
+    state: query.state,
+    queryKey: query.queryKey,
+    queryHash: query.queryHash,
+    ...(query.meta && { meta: query.meta }),
+  }
+
+  return obj
+}
+
+// Base Query Function that is used to create the query.
+export function useBaseQuery<
+  TQueryFnData,
+  TError,
+  TData,
+  TQueryData,
+  TQueryKey extends QueryKey,
+>(
+  options: Accessor<
+    UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>
+  >,
+  Observer: typeof QueryObserver,
+  queryClient?: Accessor<QueryClient>,
+) {
+  type ResourceData = QueryObserverResult<TData, TError>
+
+  const client = createMemo(() => useQueryClient(queryClient?.()))
+  const isRestoring = useIsRestoring()
+  // There are times when we run a query on the server but the resource is never read
+  // This could lead to times when the queryObserver is unsubscribed before the resource has loaded
+  // Causing a time out error. To prevent this we will queue the unsubscribe if the cleanup is called
+  // before the resource has loaded
+  let unsubscribeQueued = false
+
+  const defaultedOptions = createMemo(() => {
+    const defaultOptions = client().defaultQueryOptions(options())
+    defaultOptions._optimisticResults = isRestoring()
+      ? 'isRestoring'
+      : 'optimistic'
+    defaultOptions.structuralSharing = false
+    if (isServer) {
+      defaultOptions.retry = false
+      defaultOptions.throwOnError = true
+      // Enable prefetch during render for SSR - required for createResource to work
+      // Without this, queries wait for effects which never run on the server
+      defaultOptions.experimental_prefetchInRender = true
+    }
+    return defaultOptions
+  })
+  const initialOptions = defaultedOptions()
+
+  const [observer, setObserver] = createSignal(
+    new Observer(client(), defaultedOptions()),
+  )
+
+  let observerResult = observer().getOptimisticResult(defaultedOptions())
+  const [state, setState] =
+    createStore<QueryObserverResult<TData, TError>>(observerResult)
+
+  const createServerSubscriber = (
+    resolve: (
+      data: ResourceData | PromiseLike<ResourceData | undefined> | undefined,
+    ) => void,
+    reject: (reason?: any) => void,
+  ) => {
+    return observer().subscribe((result) => {
+      notifyManager.batchCalls(() => {
+        const query = observer().getCurrentQuery()
+        const unwrappedResult = hydratableObserverResult(query, result)
+
+        if (result.data !== undefined && unwrappedResult.isError) {
+          reject(unwrappedResult.error)
+          unsubscribeIfQueued()
+        } else {
+          resolve(unwrappedResult)
+          unsubscribeIfQueued()
+        }
+      })()
+    })
+  }
+
+  const unsubscribeIfQueued = () => {
+    if (unsubscribeQueued) {
+      unsubscribe?.()
+      unsubscribeQueued = false
+    }
+  }
+
+  const createClientSubscriber = () => {
+    const obs = observer()
+    return obs.subscribe((result) => {
+      observerResult = result
+      queueMicrotask(() => {
+        if (unsubscribe) {
+          refetch()
+        }
+      })
+    })
+  }
+
+  function setStateWithReconciliation(res: typeof observerResult) {
+    const opts = observer().options
+    // @ts-expect-error - Reconcile option is not correctly typed internally
+    const reconcileOptions = opts.reconcile
+
+    setState((store) => {
+      return reconcileFn(
+        store,
+        res,
+        reconcileOptions === undefined ? false : reconcileOptions,
+        opts.queryHash,
+      )
+    })
+  }
+
+  function createDeepSignal<T>(): Signal<T> {
+    return [
+      () => state,
+      (v: any) => {
+        const unwrapped = unwrap(state)
+        if (typeof v === 'function') {
+          v = v(unwrapped)
+        }
+        // Hydration data exists on first load after SSR,
+        // and should be removed from the observer result
+        if (v?.hydrationData) {
+          const { hydrationData, ...rest } = v
+          v = rest
+        }
+        setStateWithReconciliation(v)
+      },
+    ] as Signal<T>
+  }
+
+  /**
+   * Unsubscribe is set lazily, so that we can subscribe after hydration when needed.
+   */
+  let unsubscribe: (() => void) | null = null
+
+  /*
+    Fixes #7275
+    In a few cases, the observer could unmount before the resource is loaded.
+    This leads to Suspense boundaries to be suspended indefinitely.
+    This resolver will be called when the observer is unmounting
+    but the resource is still in a loading state
+  */
+  let resolver: ((value: ResourceData) => void) | null = null
+  const [queryResource, { refetch }] = createResource<ResourceData | undefined>(
+    () => {
+      const obs = observer()
+      return new Promise((resolve, reject) => {
+        resolver = resolve
+        if (isServer) {
+          unsubscribe = createServerSubscriber(resolve, reject)
+        } else if (!unsubscribe && !isRestoring()) {
+          unsubscribe = createClientSubscriber()
+        }
+        obs.updateResult()
+
+        if (
+          observerResult.isError &&
+          !observerResult.isFetching &&
+          !isRestoring() &&
+          shouldThrowError(obs.options.throwOnError, [
+            observerResult.error,
+            obs.getCurrentQuery(),
+          ])
+        ) {
+          setStateWithReconciliation(observerResult)
+          return reject(observerResult.error)
+        }
+        if (!observerResult.isLoading) {
+          resolver = null
+          return resolve(
+            hydratableObserverResult(obs.getCurrentQuery(), observerResult),
+          )
+        }
+
+        setStateWithReconciliation(observerResult)
+      })
+    },
+    {
+      storage: createDeepSignal,
+
+      get deferStream() {
+        return options().deferStream
+      },
+
+      /**
+       * If this resource was populated on the server (either sync render, or streamed in over time), onHydrated
+       * will be called. This is the point at which we can hydrate the query cache state, and setup the query subscriber.
+       *
+       * Leveraging onHydrated allows us to plug into the async and streaming support that solidjs resources already support.
+       *
+       * Note that this is only invoked on the client, for queries that were originally run on the server.
+       */
+      onHydrated(_k, info) {
+        if (info.value && 'hydrationData' in info.value) {
+          hydrate(client(), {
+            // @ts-expect-error - hydrationData is not correctly typed internally
+            queries: [{ ...info.value.hydrationData }],
+          })
+        }
+
+        if (unsubscribe) return
+        /**
+         * Do not refetch query on mount if query was fetched on server,
+         * even if `staleTime` is not set.
+         */
+        const newOptions = { ...initialOptions }
+        if (
+          (initialOptions.staleTime || !initialOptions.initialData) &&
+          info.value
+        ) {
+          newOptions.refetchOnMount = false
+        }
+        // Setting the options as an immutable object to prevent
+        // wonky behavior with observer subscriptions
+        observer().setOptions(newOptions)
+        setStateWithReconciliation(observer().getOptimisticResult(newOptions))
+        unsubscribe = createClientSubscriber()
+      },
+    },
+  )
+
+  createComputed(
+    on(
+      client,
+      (c) => {
+        if (unsubscribe) {
+          unsubscribe()
+        }
+        const newObserver = new Observer(c, defaultedOptions())
+        unsubscribe = createClientSubscriber()
+        setObserver(newObserver)
+      },
+      {
+        defer: true,
+      },
+    ),
+  )
+
+  createComputed(
+    on(
+      isRestoring,
+      (restoring) => {
+        if (!restoring && !isServer) {
+          refetch()
+        }
+      },
+      { defer: true },
+    ),
+  )
+
+  onCleanup(() => {
+    if (isServer && queryResource.loading) {
+      unsubscribeQueued = true
+      return
+    }
+    if (unsubscribe) {
+      unsubscribe()
+      unsubscribe = null
+    }
+    if (resolver && !isServer) {
+      resolver(observerResult)
+      resolver = null
+    }
+  })
+
+  createComputed(
+    on(
+      [observer, defaultedOptions],
+      ([obs, opts]) => {
+        obs.setOptions(opts)
+        setStateWithReconciliation(obs.getOptimisticResult(opts))
+        refetch()
+      },
+      { defer: true },
+    ),
+  )
+
+  const handler = {
+    get(
+      target: QueryObserverResult<TData, TError>,
+      prop: keyof QueryObserverResult<TData, TError>,
+    ): any {
+      if (prop === 'data') {
+        if (state.data !== undefined) {
+          return queryResource.latest?.data
+        }
+        return queryResource()?.data
+      }
+      return Reflect.get(target, prop)
+    },
+  }
+
+  return new Proxy(state, handler)
+}

node_modules/@tanstack/solid-query/src/useInfiniteQuery.ts

@@ -0,0 +1,76 @@
+import { InfiniteQueryObserver } from '@tanstack/query-core'
+import { createMemo } from 'solid-js'
+import { useBaseQuery } from './useBaseQuery'
+import type {
+  DefaultError,
+  InfiniteData,
+  QueryKey,
+  QueryObserver,
+} from '@tanstack/query-core'
+import type { QueryClient } from './QueryClient'
+import type {
+  DefinedUseInfiniteQueryResult,
+  UseInfiniteQueryOptions,
+  UseInfiniteQueryResult,
+} from './types'
+import type { Accessor } from 'solid-js'
+import type {
+  DefinedInitialDataInfiniteOptions,
+  UndefinedInitialDataInfiniteOptions,
+} from './infiniteQueryOptions'
+
+export function useInfiniteQuery<
+  TQueryFnData,
+  TError = DefaultError,
+  TData = InfiniteData<TQueryFnData>,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
+>(
+  options: DefinedInitialDataInfiniteOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryKey,
+    TPageParam
+  >,
+  queryClient?: Accessor<QueryClient>,
+): DefinedUseInfiniteQueryResult<TData, TError>
+export function useInfiniteQuery<
+  TQueryFnData,
+  TError = DefaultError,
+  TData = InfiniteData<TQueryFnData>,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
+>(
+  options: UndefinedInitialDataInfiniteOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryKey,
+    TPageParam
+  >,
+  queryClient?: Accessor<QueryClient>,
+): UseInfiniteQueryResult<TData, TError>
+
+export function useInfiniteQuery<
+  TQueryFnData,
+  TError = DefaultError,
+  TData = InfiniteData<TQueryFnData>,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
+>(
+  options: UseInfiniteQueryOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryKey,
+    TPageParam
+  >,
+  queryClient?: Accessor<QueryClient>,
+): UseInfiniteQueryResult<TData, TError> {
+  return useBaseQuery(
+    createMemo(() => options()),
+    InfiniteQueryObserver as typeof QueryObserver,
+    queryClient,
+  ) as UseInfiniteQueryResult<TData, TError>
+}

node_modules/@tanstack/solid-query/src/useIsFetching.ts

@@ -0,0 +1,23 @@
+import { createMemo, createSignal, onCleanup } from 'solid-js'
+import { useQueryClient } from './QueryClientProvider'
+import type { QueryFilters } from '@tanstack/query-core'
+import type { QueryClient } from './QueryClient'
+import type { Accessor } from 'solid-js'
+
+export function useIsFetching(
+  filters?: Accessor<QueryFilters>,
+  queryClient?: Accessor<QueryClient>,
+): Accessor<number> {
+  const client = createMemo(() => useQueryClient(queryClient?.()))
+  const queryCache = createMemo(() => client().getQueryCache())
+
+  const [fetches, setFetches] = createSignal(client().isFetching(filters?.()))
+
+  const unsubscribe = queryCache().subscribe(() => {
+    setFetches(client().isFetching(filters?.()))
+  })
+
+  onCleanup(unsubscribe)
+
+  return fetches
+}

node_modules/@tanstack/solid-query/src/useIsMutating.ts

@@ -0,0 +1,25 @@
+import { createMemo, createSignal, onCleanup } from 'solid-js'
+import { useQueryClient } from './QueryClientProvider'
+import type { MutationFilters } from '@tanstack/query-core'
+import type { QueryClient } from './QueryClient'
+import type { Accessor } from 'solid-js'
+
+export function useIsMutating(
+  filters?: Accessor<MutationFilters>,
+  queryClient?: Accessor<QueryClient>,
+): Accessor<number> {
+  const client = createMemo(() => useQueryClient(queryClient?.()))
+  const mutationCache = createMemo(() => client().getMutationCache())
+
+  const [mutations, setMutations] = createSignal(
+    client().isMutating(filters?.()),
+  )
+
+  const unsubscribe = mutationCache().subscribe((_result) => {
+    setMutations(client().isMutating(filters?.()))
+  })
+
+  onCleanup(unsubscribe)
+
+  return mutations
+}

node_modules/@tanstack/solid-query/src/useMutation.ts

@@ -0,0 +1,79 @@
+import { MutationObserver, noop, shouldThrowError } from '@tanstack/query-core'
+import { createComputed, createMemo, on, onCleanup } from 'solid-js'
+import { createStore } from 'solid-js/store'
+import { useQueryClient } from './QueryClientProvider'
+import type { DefaultError } from '@tanstack/query-core'
+import type { QueryClient } from './QueryClient'
+import type {
+  UseMutateFunction,
+  UseMutationOptions,
+  UseMutationResult,
+} from './types'
+import type { Accessor } from 'solid-js'
+
+// HOOK
+export function useMutation<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = void,
+  TOnMutateResult = unknown,
+>(
+  options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,
+  queryClient?: Accessor<QueryClient>,
+): UseMutationResult<TData, TError, TVariables, TOnMutateResult> {
+  const client = createMemo(() => useQueryClient(queryClient?.()))
+
+  const observer = new MutationObserver<
+    TData,
+    TError,
+    TVariables,
+    TOnMutateResult
+  >(client(), options())
+
+  const mutate: UseMutateFunction<
+    TData,
+    TError,
+    TVariables,
+    TOnMutateResult
+  > = (variables, mutateOptions) => {
+    observer.mutate(variables, mutateOptions).catch(noop)
+  }
+
+  const [state, setState] = createStore<
+    UseMutationResult<TData, TError, TVariables, TOnMutateResult>
+  >({
+    ...observer.getCurrentResult(),
+    mutate,
+    mutateAsync: observer.getCurrentResult().mutate,
+  })
+
+  createComputed(() => {
+    observer.setOptions(options())
+  })
+
+  createComputed(
+    on(
+      () => state.status,
+      () => {
+        if (
+          state.isError &&
+          shouldThrowError(observer.options.throwOnError, [state.error])
+        ) {
+          throw state.error
+        }
+      },
+    ),
+  )
+
+  const unsubscribe = observer.subscribe((result) => {
+    setState({
+      ...result,
+      mutate,
+      mutateAsync: result.mutate,
+    })
+  })
+
+  onCleanup(unsubscribe)
+
+  return state
+}

node_modules/@tanstack/solid-query/src/useMutationState.ts

@@ -0,0 +1,56 @@
+import { createEffect, createMemo, createSignal, onCleanup } from 'solid-js'
+import { replaceEqualDeep } from '@tanstack/query-core'
+import { useQueryClient } from './QueryClientProvider'
+import type {
+  Mutation,
+  MutationCache,
+  MutationFilters,
+  MutationState,
+} from '@tanstack/query-core'
+import type { Accessor } from 'solid-js'
+import type { QueryClient } from './QueryClient'
+
+type MutationStateOptions<TResult = MutationState> = {
+  filters?: MutationFilters
+  select?: (mutation: Mutation) => TResult
+}
+
+function getResult<TResult = MutationState>(
+  mutationCache: MutationCache,
+  options: MutationStateOptions<TResult>,
+): Array<TResult> {
+  return mutationCache
+    .findAll(options.filters)
+    .map(
+      (mutation): TResult =>
+        (options.select ? options.select(mutation) : mutation.state) as TResult,
+    )
+}
+
+export function useMutationState<TResult = MutationState>(
+  options: Accessor<MutationStateOptions<TResult>> = () => ({}),
+  queryClient?: Accessor<QueryClient>,
+): Accessor<Array<TResult>> {
+  const client = createMemo(() => useQueryClient(queryClient?.()))
+  const mutationCache = createMemo(() => client().getMutationCache())
+
+  const [result, setResult] = createSignal(
+    getResult(mutationCache(), options()),
+  )
+
+  createEffect(() => {
+    const unsubscribe = mutationCache().subscribe(() => {
+      const nextResult = replaceEqualDeep(
+        result(),
+        getResult(mutationCache(), options()),
+      )
+      if (result() !== nextResult) {
+        setResult(nextResult)
+      }
+    })
+
+    onCleanup(unsubscribe)
+  })
+
+  return result
+}

node_modules/@tanstack/solid-query/src/useQueries.ts

@@ -0,0 +1,343 @@
+import { QueriesObserver, noop } from '@tanstack/query-core'
+import { createStore, unwrap } from 'solid-js/store'
+import {
+  batch,
+  createComputed,
+  createMemo,
+  createRenderEffect,
+  createResource,
+  mergeProps,
+  on,
+  onCleanup,
+  onMount,
+} from 'solid-js'
+import { useQueryClient } from './QueryClientProvider'
+import { useIsRestoring } from './isRestoring'
+import type { SolidQueryOptions, UseQueryResult } from './types'
+import type { Accessor } from 'solid-js'
+import type { QueryClient } from './QueryClient'
+import type {
+  DefaultError,
+  OmitKeyof,
+  QueriesObserverOptions,
+  QueriesPlaceholderDataFunction,
+  QueryFunction,
+  QueryKey,
+  QueryObserverOptions,
+  QueryObserverResult,
+  ThrowOnError,
+} from '@tanstack/query-core'
+
+// This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
+// `placeholderData` function does not have a parameter
+type UseQueryOptionsForUseQueries<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> = OmitKeyof<
+  SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+  'placeholderData' | 'suspense'
+> & {
+  placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>
+  /**
+   * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
+   * The `data` property on useQueries is a plain object and not a SolidJS Resource.
+   * It will not suspend when the data is loading.
+   * Setting `suspense` to `true` will be a no-op.
+   */
+  suspense?: boolean
+}
+
+// Avoid TS depth-limit error in case of large array literal
+type MAXIMUM_DEPTH = 20
+
+// Widen the type of the symbol to enable type inference even if skipToken is not immutable.
+type SkipTokenForUseQueries = symbol
+
+type GetOptions<T> =
+  // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }
+  T extends {
+    queryFnData: infer TQueryFnData
+    error?: infer TError
+    data: infer TData
+  }
+    ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>
+    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
+      ? UseQueryOptionsForUseQueries<TQueryFnData, TError>
+      : T extends { data: infer TData; error?: infer TError }
+        ? UseQueryOptionsForUseQueries<unknown, TError, TData>
+        : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]
+          T extends [infer TQueryFnData, infer TError, infer TData]
+          ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>
+          : T extends [infer TQueryFnData, infer TError]
+            ? UseQueryOptionsForUseQueries<TQueryFnData, TError>
+            : T extends [infer TQueryFnData]
+              ? UseQueryOptionsForUseQueries<TQueryFnData>
+              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided
+                T extends {
+                    queryFn?:
+                      | QueryFunction<infer TQueryFnData, infer TQueryKey>
+                      | SkipTokenForUseQueries
+                    select?: (data: any) => infer TData
+                    throwOnError?: ThrowOnError<any, infer TError, any, any>
+                  }
+                ? UseQueryOptionsForUseQueries<
+                    TQueryFnData,
+                    unknown extends TError ? DefaultError : TError,
+                    unknown extends TData ? TQueryFnData : TData,
+                    TQueryKey
+                  >
+                : // Fallback
+                  UseQueryOptionsForUseQueries
+
+type GetResults<T> =
+  // Part 1: responsible for mapping explicit type parameter to function result, if object
+  T extends { queryFnData: any; error?: infer TError; data: infer TData }
+    ? UseQueryResult<TData, TError>
+    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
+      ? UseQueryResult<TQueryFnData, TError>
+      : T extends { data: infer TData; error?: infer TError }
+        ? UseQueryResult<TData, TError>
+        : // Part 2: responsible for mapping explicit type parameter to function result, if tuple
+          T extends [any, infer TError, infer TData]
+          ? UseQueryResult<TData, TError>
+          : T extends [infer TQueryFnData, infer TError]
+            ? UseQueryResult<TQueryFnData, TError>
+            : T extends [infer TQueryFnData]
+              ? UseQueryResult<TQueryFnData>
+              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided
+                T extends {
+                    queryFn?:
+                      | QueryFunction<infer TQueryFnData, any>
+                      | SkipTokenForUseQueries
+                    select?: (data: any) => infer TData
+                    throwOnError?: ThrowOnError<any, infer TError, any, any>
+                  }
+                ? UseQueryResult<
+                    unknown extends TData ? TQueryFnData : TData,
+                    unknown extends TError ? DefaultError : TError
+                  >
+                : // Fallback
+                  UseQueryResult
+
+/**
+ * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ */
+type QueriesOptions<
+  T extends Array<any>,
+  TResult extends Array<any> = [],
+  TDepth extends ReadonlyArray<number> = [],
+> = TDepth['length'] extends MAXIMUM_DEPTH
+  ? Array<UseQueryOptionsForUseQueries>
+  : T extends []
+    ? []
+    : T extends [infer Head]
+      ? [...TResult, GetOptions<Head>]
+      : T extends [infer Head, ...infer Tail]
+        ? QueriesOptions<
+            [...Tail],
+            [...TResult, GetOptions<Head>],
+            [...TDepth, 1]
+          >
+        : ReadonlyArray<unknown> extends T
+          ? T
+          : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!
+            // use this to infer the param types in the case of Array.map() argument
+            T extends Array<
+                UseQueryOptionsForUseQueries<
+                  infer TQueryFnData,
+                  infer TError,
+                  infer TData,
+                  infer TQueryKey
+                >
+              >
+            ? Array<
+                UseQueryOptionsForUseQueries<
+                  TQueryFnData,
+                  TError,
+                  TData,
+                  TQueryKey
+                >
+              >
+            : // Fallback
+              Array<UseQueryOptionsForUseQueries>
+
+/**
+ * QueriesResults reducer recursively maps type param to results
+ */
+type QueriesResults<
+  T extends Array<any>,
+  TResult extends Array<any> = [],
+  TDepth extends ReadonlyArray<number> = [],
+> = TDepth['length'] extends MAXIMUM_DEPTH
+  ? Array<UseQueryResult>
+  : T extends []
+    ? []
+    : T extends [infer Head]
+      ? [...TResult, GetResults<Head>]
+      : T extends [infer Head, ...infer Tail]
+        ? QueriesResults<
+            [...Tail],
+            [...TResult, GetResults<Head>],
+            [...TDepth, 1]
+          >
+        : { [K in keyof T]: GetResults<T[K]> }
+
+export function useQueries<
+  T extends Array<any>,
+  TCombinedResult extends QueriesResults<T> = QueriesResults<T>,
+>(
+  queriesOptions: Accessor<{
+    queries:
+      | readonly [...QueriesOptions<T>]
+      | readonly [...{ [K in keyof T]: GetOptions<T[K]> }]
+    combine?: (result: QueriesResults<T>) => TCombinedResult
+  }>,
+  queryClient?: Accessor<QueryClient>,
+): TCombinedResult {
+  const client = createMemo(() => useQueryClient(queryClient?.()))
+  const isRestoring = useIsRestoring()
+
+  const defaultedQueries = createMemo(() =>
+    queriesOptions().queries.map((options) =>
+      mergeProps(
+        client().defaultQueryOptions(options as QueryObserverOptions),
+        {
+          get _optimisticResults() {
+            return isRestoring() ? 'isRestoring' : 'optimistic'
+          },
+        },
+      ),
+    ),
+  )
+
+  const observer = new QueriesObserver(
+    client(),
+    defaultedQueries(),
+    queriesOptions().combine
+      ? ({
+          combine: queriesOptions().combine,
+        } as QueriesObserverOptions<TCombinedResult>)
+      : undefined,
+  )
+
+  const [state, setState] = createStore<TCombinedResult>(
+    observer.getOptimisticResult(
+      defaultedQueries(),
+      (queriesOptions() as QueriesObserverOptions<TCombinedResult>).combine,
+    )[1](),
+  )
+
+  createRenderEffect(
+    on(
+      () => queriesOptions().queries.length,
+      () =>
+        setState(
+          observer.getOptimisticResult(
+            defaultedQueries(),
+            (queriesOptions() as QueriesObserverOptions<TCombinedResult>)
+              .combine,
+          )[1](),
+        ),
+    ),
+  )
+
+  const dataResources = createMemo(
+    on(
+      () => state.length,
+      () =>
+        state.map((queryRes) => {
+          const dataPromise = () =>
+            new Promise((resolve) => {
+              if (queryRes.isFetching && queryRes.isLoading) return
+              resolve(unwrap(queryRes.data))
+            })
+          return createResource(dataPromise)
+        }),
+    ),
+  )
+
+  batch(() => {
+    const dataResources_ = dataResources()
+    for (let index = 0; index < dataResources_.length; index++) {
+      const dataResource = dataResources_[index]!
+      dataResource[1].mutate(() => unwrap(state[index]!.data))
+      dataResource[1].refetch()
+    }
+  })
+
+  let taskQueue: Array<() => void> = []
+  const subscribeToObserver = () =>
+    observer.subscribe((result) => {
+      taskQueue.push(() => {
+        batch(() => {
+          const dataResources_ = dataResources()
+          for (let index = 0; index < dataResources_.length; index++) {
+            const dataResource = dataResources_[index]!
+            const unwrappedResult = { ...unwrap(result[index]) }
+            // @ts-expect-error typescript pedantry regarding the possible range of index
+            setState(index, unwrap(unwrappedResult))
+            dataResource[1].mutate(() => unwrap(state[index]!.data))
+            dataResource[1].refetch()
+          }
+        })
+      })
+
+      queueMicrotask(() => {
+        const taskToRun = taskQueue.pop()
+        if (taskToRun) taskToRun()
+        taskQueue = []
+      })
+    })
+
+  let unsubscribe: () => void = noop
+  createComputed<() => void>((cleanup) => {
+    cleanup?.()
+    unsubscribe = isRestoring() ? noop : subscribeToObserver()
+    // cleanup needs to be scheduled after synchronous effects take place
+    return () => queueMicrotask(unsubscribe)
+  })
+  onCleanup(unsubscribe)
+
+  onMount(() => {
+    observer.setQueries(
+      defaultedQueries(),
+      queriesOptions().combine
+        ? ({
+            combine: queriesOptions().combine,
+          } as QueriesObserverOptions<TCombinedResult>)
+        : undefined,
+    )
+  })
+
+  createComputed(() => {
+    observer.setQueries(
+      defaultedQueries(),
+      queriesOptions().combine
+        ? ({
+            combine: queriesOptions().combine,
+          } as QueriesObserverOptions<TCombinedResult>)
+        : undefined,
+    )
+  })
+
+  const handler = (index: number) => ({
+    get(target: QueryObserverResult, prop: keyof QueryObserverResult): any {
+      if (prop === 'data') {
+        return dataResources()[index]![0]()
+      }
+      return Reflect.get(target, prop)
+    },
+  })
+
+  const getProxies = () =>
+    state.map((s, index) => {
+      return new Proxy(s, handler(index))
+    })
+
+  const [proxyState, setProxyState] = createStore(getProxies())
+  createRenderEffect(() => setProxyState(getProxies()))
+
+  return proxyState as TCombinedResult
+}

node_modules/@tanstack/solid-query/src/useQuery.ts

@@ -0,0 +1,50 @@
+import { QueryObserver } from '@tanstack/query-core'
+import { createMemo } from 'solid-js'
+import { useBaseQuery } from './useBaseQuery'
+import type { DefaultError, QueryKey } from '@tanstack/query-core'
+import type { QueryClient } from './QueryClient'
+import type { Accessor } from 'solid-js'
+import type {
+  DefinedUseQueryResult,
+  UseQueryOptions,
+  UseQueryResult,
+} from './types'
+import type {
+  DefinedInitialDataOptions,
+  UndefinedInitialDataOptions,
+} from './queryOptions'
+
+export function useQuery<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+>(
+  options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
+  queryClient?: () => QueryClient,
+): UseQueryResult<TData, TError>
+
+export function useQuery<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+>(
+  options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
+  queryClient?: () => QueryClient,
+): DefinedUseQueryResult<TData, TError>
+export function useQuery<
+  TQueryFnData,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+>(
+  options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+  queryClient?: Accessor<QueryClient>,
+) {
+  return useBaseQuery(
+    createMemo(() => options()),
+    QueryObserver,
+    queryClient,
+  )
+}