import * as _aydee_app_eden from '@aydee-app/eden';
import { EdenRequestOptions, InferRouteOptions, EdenClient, EdenClientError, InferRouteOutput, InferRouteError, EmptyToVoid, InferRouteBody, ExtractEdenTreatyRouteParams, HttpQueryMethod, HttpMutationMethod, HttpSubscriptionMethod, ExtractEdenTreatyRouteParamsInput, TypeError, EdenTreatyClient, EdenCreateClient, HTTPLinkOptions, HttpBatchLinkOptions } from '@aydee-app/eden';
export * from '@aydee-app/eden';
import { StoreOrVal, QueryClient, DehydratedState, FetchInfiniteQueryOptions, FetchQueryOptions, InfiniteData, InvalidateQueryFilters, InvalidateOptions, QueryFilters, ResetOptions, RefetchQueryFilters, RefetchOptions, CancelOptions, Updater, SetDataOptions, QueryKey, MutationOptions, CreateInfiniteQueryOptions, CreateInfiniteQueryResult, SkipToken, CreateMutationOptions, CreateBaseMutationResult, MutateOptions, CreateBaseQueryOptions, CreateQueryResult, InitialDataFunction, DefinedCreateQueryResult, CreateQueryOptions, QueriesResults, QueriesOptions, Query } from '@tanstack/svelte-query';
import { AnyElysia, MaybePromise, RouteSchema } from 'elysia';
import { Prettify } from 'elysia/types';
import { Readable } from 'svelte/store';

/**
 * Options to customize the behavior of the query or fetch.
 */
type EdenQueryRequestOptions<T extends AnyElysia = AnyElysia> = 
/**
 * Use svelte-query's internal AbortSignals instead of allowing user provided signals.
 */
Omit<EdenRequestOptions<T>, 'signal'> & {
    /**
     * Opt out or into aborting request on unmount
     */
    abortOnUnmount?: boolean;
    /**
     * Overrides for svelte-query hooks.
     */
    overrides?: EdenQueryOverrides;
    /**
     * SSR option...
     */
    dehydrated?: boolean | DehydratedState;
};
type EdenQueryOverrides = {
    createMutation?: Partial<CreateMutationOverride>;
};
type CreateMutationOverride = {
    onSuccess: (options: CreateMutationOverrideOnSuccessOptions) => MaybePromise<unknown>;
};
type CreateMutationOverrideOnSuccessOptions = {
    originalFn: () => StoreOrVal<unknown>;
    queryClient: QueryClient;
    meta: Record<string, unknown>;
};

type EdenQueryConfig<T extends AnyElysia = AnyElysia> = EdenQueryRequestOptions<T> & {
    /**
     * Override the default context provider
     * @default undefined
     */
    context?: any;
};

/**
 * Makes the object recursively optional
 * @internal
 */
type DeepPartial<TObject> = TObject extends object ? {
    [P in keyof TObject]?: DeepPartial<TObject[P]>;
} : TObject;
/**
 * Omits the key without removing a potential union
 * @internal
 */
type DistributiveOmit<TObj, TKey extends keyof any> = TObj extends any ? Omit<TObj, TKey> : never;
/**
 * @internal
 */
type IntersectionError<TKey extends string> = `The property '${TKey}' in your router collides with a built-in method, rename this router or procedure on your backend.`;
/**
 * @internal
 */
type ProtectedIntersection<TType, TWith> = keyof TType & keyof TWith extends never ? TType & TWith : IntersectionError<string & keyof TType & keyof TWith>;
/**
 * Simple utility that overrides top level properties from `T` with the matching properties from `U`.
 */
type Override<T, U> = Omit<T, keyof U> & U;

/**
 * Key in params or query that indicates GET routes that are eligible for infinite queries.
 */
type InfiniteCursorKey = 'cursor';
/**
 * When providing request input to infinite queries, omit the "cursor" and "direction" properties
 * since these will be set by the integration.
 */
type ReservedInfiniteQueryKeys = InfiniteCursorKey | 'direction';
/**
 * Given T, which is presumably a {@link RouteSchema}, merge the "params" and "query" types,
 * then extract the "cursor".
 */
type ExtractCursorType<T> = T extends Record<string, any> ? (T['params'] & T['query'])['cursor'] : unknown;
type ExtractQueryCursor<T> = T extends Record<string, any> ? T['cursor'] : unknown;

/**
 * Additional options for queries.
 */
type EdenQueryBaseOptions = {
    /**
     * eden-related options
     */
    eden?: EdenQueryRequestOptions;
};

/**
 * A well-defined query type used when creating query keys for a specific type of operation.
 */
type EdenKnownQueryType = 'query' | 'infinite';
/**
 * Valid query types for creating query keys.
 */
type EdenQueryType = EdenKnownQueryType | 'any';
/**
 * QueryKey used internally. Consists of a tuple with an array key and metadata.
 */
type EdenQueryKey<TKey extends readonly any[] = readonly string[], TInput = unknown, TType extends EdenKnownQueryType = EdenKnownQueryType> = [key: TKey, metadata?: {
    input?: TInput;
    type?: TType;
}];
type EdenQueryKeyOptions = InferRouteOptions & {
    body?: any;
};
type EdenMutationKey = [readonly string[]];

type EdenFetchInfiniteQueryOptions<TInput, TOutput, TError> = DistributiveOmit<FetchInfiniteQueryOptions<TOutput, TError, TOutput, EdenQueryKey, ExtractCursorType<TInput>>, 'queryKey' | 'initialPageParam'> & EdenQueryBaseOptions & {
    initialCursor?: ExtractCursorType<TInput>;
};

type EdenFetchQueryOptions<TOutput, TError> = DistributiveOmit<FetchQueryOptions<TOutput, TError>, 'queryKey'> & EdenQueryBaseOptions;

type EdenContextPropsBase<TElysia extends AnyElysia, _TSSRContext = unknown> = {
    /**
     * Untyped client for making requests.
     */
    client: EdenClient<TElysia>;
    /**
     * Whether to forward the `signal` from svelte-query to fetch call.
     *
     * @default false
     *
     * @deprecated pass abortOnUnmount to `createTRPCReact` instead
     */
    abortOnUnmount?: boolean;
};
type EdenContextProps<TRouter extends AnyElysia, TSSRContext> = EdenContextPropsBase<TRouter, TSSRContext> & {
    /**
     * The svelte-query `QueryClient`
     */
    queryClient: QueryClient;
};
type EdenContextState<TRouter extends AnyElysia, TSSRContext = undefined> = Required<EdenContextProps<TRouter, TSSRContext>> & EdenQueryUtils<TRouter>;
type EdenQueryUtils<TRouter extends AnyElysia> = {
    /**
     * @link https://tanstack.com/query/v5/docs/reference/QueryClient#queryclientfetchquery
     */
    fetchQuery: (queryKey: EdenQueryKey, opts?: EdenFetchQueryOptions<unknown, EdenClientError<TRouter>>) => Promise<unknown>;
    /**
     * @link https://tanstack.com/query/v5/docs/reference/QueryClient#queryclientfetchinfinitequery
     */
    fetchInfiniteQuery: (queryKey: EdenQueryKey, opts?: EdenFetchInfiniteQueryOptions<unknown, unknown, EdenClientError<TRouter>>) => Promise<InfiniteData<unknown, unknown>>;
    /**
     * @link https://tanstack.com/query/v5/docs/framework/react/guides/prefetching
     */
    prefetchQuery: (queryKey: EdenQueryKey, opts?: EdenFetchQueryOptions<unknown, EdenClientError<TRouter>>) => Promise<void>;
    /**
     * @link https://tanstack.com/query/v5/docs/reference/QueryClient#queryclientprefetchinfinitequery
     */
    prefetchInfiniteQuery: (queryKey: EdenQueryKey, opts?: EdenFetchInfiniteQueryOptions<unknown, unknown, EdenClientError<TRouter>>) => Promise<void>;
    /**
     * @link https://tanstack.com/query/v5/docs/reference/QueryClient#queryclientensurequerydata
     */
    ensureQueryData: (queryKey: EdenQueryKey, opts?: EdenFetchQueryOptions<unknown, EdenClientError<TRouter>>) => Promise<unknown>;
    /**
     * @link https://tanstack.com/query/v5/docs/framework/react/guides/query-invalidation
     */
    invalidateQueries: (queryKey: EdenQueryKey, filters?: InvalidateQueryFilters, options?: InvalidateOptions) => Promise<void>;
    /**
     * @link https://tanstack.com/query/v5/docs/reference/QueryClient#queryclientresetqueries
     */
    resetQueries: (queryKey: EdenQueryKey, filters?: QueryFilters, options?: ResetOptions) => Promise<void>;
    /**
     * @link https://tanstack.com/query/v5/docs/reference/QueryClient#queryclientrefetchqueries
     */
    refetchQueries: (queryKey: EdenQueryKey, filters?: RefetchQueryFilters, options?: RefetchOptions) => Promise<void>;
    /**
     * @link https://tanstack.com/query/v5/docs/framework/react/guides/query-cancellation
     */
    cancelQuery: (queryKey: EdenQueryKey, options?: CancelOptions) => Promise<void>;
    /**
     * @link https://tanstack.com/query/v5/docs/reference/QueryClient#queryclientsetquerydata
     */
    setQueryData: (queryKey: EdenQueryKey, updater: Updater<unknown, unknown>, options?: SetDataOptions) => void;
    /**
     * @link https://tanstack.com/query/v5/docs/reference/QueryClient#queryclientsetqueriesdata
     */
    setQueriesData: (queryKey: EdenQueryKey, filters: QueryFilters, updater: Updater<unknown, unknown>, options?: SetDataOptions) => [QueryKey, unknown][];
    /**
     * @link https://tanstack.com/query/v5/docs/reference/QueryClient#queryclientgetquerydata
     */
    getQueryData: (queryKey: EdenQueryKey) => unknown;
    /**
     * @link https://tanstack.com/query/v5/docs/reference/QueryClient#queryclientsetquerydata
     */
    setInfiniteQueryData: (queryKey: EdenQueryKey, updater: Updater<InfiniteData<unknown> | undefined, InfiniteData<unknown> | undefined>, options?: SetDataOptions) => void;
    /**
     * @link https://tanstack.com/query/v5/docs/reference/QueryClient#queryclientgetquerydata
     */
    getInfiniteQueryData: (queryKey: EdenQueryKey) => InfiniteData<unknown> | undefined;
    /**
     * @link https://tanstack.com/query/latest/docs/reference/QueryClient/#queryclientsetmutationdefaults
     */
    setMutationDefaults: (mutationKey: EdenMutationKey, options: MutationOptions | ((args: {
        canonicalMutationFn: (input: unknown) => Promise<unknown>;
    }) => MutationOptions)) => void;
    /**
     * @link https://tanstack.com/query/latest/docs/reference/QueryClient#queryclientgetmutationdefaults
     */
    getMutationDefaults: (mutationKey: EdenMutationKey) => MutationOptions | undefined;
    /**
     * @link https://tanstack.com/query/latest/docs/reference/QueryClient#queryclientismutating
     */
    isMutating: (filters: {
        mutationKey: EdenMutationKey;
    }) => number;
};

/**
 * Additional properties appended to react-query hooks by the library.
 *
 * The hooks are scoped to an `eden` property on the hook.
 *
 * @example
 *
 * const hello = eden.hello.useQuery()
 *
 * const edenPath = hello.eden.path
 */
type WithEdenQueryExtension<T = {}> = T & {
    /**
     * Additional object appended by eden-query.
     */
    eden: EdenExtendedQueryHooks;
};
/**
 * Additional hooks added to the original react-query hook result.
 */
type EdenExtendedQueryHooks = {
    /**
     * The path used to make the request.
     *
     * @example
     *
     * '/api/a/index'
     */
    path: string;
};

interface EdenCreateInfiniteQueryOptions<TInput, TOutput, TError> extends DistributiveOmit<CreateInfiniteQueryOptions<TOutput, TError, TOutput, any, ExtractQueryCursor<TInput>>, 'queryKey' | 'initialPageParam'>, EdenQueryBaseOptions {
    initialCursor?: ExtractQueryCursor<TInput>;
}
type EdenCreateInfiniteQueryResult<TData, TError, TInput> = WithEdenQueryExtension<CreateInfiniteQueryResult<InfiniteData<TData, NonNullable<ExtractQueryCursor<TInput>> | null>, TError>>;
type EdenCreateInfiniteQuery<TRoute extends RouteSchema, _TPath extends any[] = [], TInput = InferRouteOptions<TRoute>['query'], TOutput = InferRouteOutput<TRoute>, TError = InferRouteError<TRoute>, TInfiniteInput = InferRouteOptions<TRoute, ReservedInfiniteQueryKeys>['query']> = (input: StoreOrVal<EmptyToVoid<TInfiniteInput> | SkipToken>, options: EdenCreateInfiniteQueryOptions<TInput, TOutput, TError>) => EdenCreateInfiniteQueryResult<TOutput, TError, TInput>;

type EdenCreateMutationOptions<TInput, TError, TOutput, TContext = unknown> = CreateMutationOptions<TOutput, TError, TInput, TContext> & EdenQueryBaseOptions;
type EdenCreateMutationResult<TData, TError, TVariables, TContext, TInput> = WithEdenQueryExtension<Readable<Override<CreateBaseMutationResult<TData, TError, TVariables, TContext>, {
    mutateAsync: EdenAsyncMutationFunction<TData, TError, TVariables, TInput>;
    mutate: EdenMutationFunction<TData, TError, TVariables, TInput>;
}>>>;
type EdenCreateMutation<TRoute extends RouteSchema, _TPath extends any[] = [], TVariables = InferRouteBody<TRoute>, TInput = Partial<Pick<InferRouteOptions<TRoute>, 'params'>> & Omit<InferRouteOptions<TRoute>, 'params'>, TData = InferRouteOutput<TRoute>, TError = InferRouteError<TRoute>> = <TContext = unknown>(options?: EdenCreateMutationOptions<TVariables, TError, TData, TContext>) => EdenCreateMutationResult<TData, TError, TVariables, TContext, TInput>;
type EdenAsyncMutationFunction<TData, TError, TVariables, TInput> = <TContext = TData>(variables: TVariables, options: {} extends TInput ? void | (TData & MutateOptions<TData, TError, EdenCreateMutationVariables<TVariables, TInput>, TContext>) : TData & MutateOptions<TData, TError, EdenCreateMutationVariables<TVariables, TInput>, TContext>) => Promise<TContext>;
type EdenMutationFunction<TData, TError, TVariables, TInput> = <TContext = unknown>(variables: TContext, options: {} extends TInput ? void | (TData & MutateOptions<TData, TError, EdenCreateMutationVariables<TVariables, TInput>, TContext>) : TData & MutateOptions<TData, TError, EdenCreateMutationVariables<TVariables, TInput>, TContext>) => void;
/**
 * @internal
 *
 * Need to be able to provide multiple arguments to `useMutation`, since
 * Eden's mutations accept a body as the first argument, and additional options
 * as the second argument -- which are sometimes required.
 *
 * To accomplish this, eden-query intercepts the hook call to grab the args as a single object,
 * then destructures it in custom `mutate` and `asyncMutate` implementations.
 *
 * This "hack" is needed since the vanilla `useMutation` hook doesn't allow multiple args :(
 */
type EdenCreateMutationVariables<TBody = any, TOptions = {}> = {
    /**
     * The first argument provided to the `useMutation` hook, i.e. the request body.
     */
    body: TBody;
} & ({} extends TOptions ? {
    /**
     * The second argument provided to the `useMutation` hook, i.e. request options.
     */
    options?: TOptions;
} : {
    /**
     * The second argument provided to the `useMutation` hook, i.e. request options.
     */
    options: TOptions;
});

type EdenCreateQueryOptions<TOutput, TData, TError, TQueryOptsData = TOutput> = DistributiveOmit<CreateBaseQueryOptions<TOutput, TError, TData, TQueryOptsData, any>, 'queryKey'> & EdenQueryBaseOptions;
type EdenDefinedCreateQueryOptions<TOutput, TData, TError, TQueryOptsData = TOutput> = DistributiveOmit<CreateBaseQueryOptions<TOutput, TError, TData, TQueryOptsData, any>, 'queryKey'> & EdenQueryBaseOptions & {
    initialData: InitialDataFunction<TQueryOptsData> | TQueryOptsData;
};
type EdenCreateQueryResult<TData, TError> = WithEdenQueryExtension<CreateQueryResult<TData, TError>>;
type EdenDefinedCreateQueryResult<TData, TError> = WithEdenQueryExtension<DefinedCreateQueryResult<TData, TError>>;
interface EdenCreateQuery<TRoute extends RouteSchema, _TPath extends any[] = [], TInput = InferRouteOptions<TRoute>['query'], TOutput = InferRouteOutput<TRoute>, TError = InferRouteError<TRoute>> {
    <TQueryFnData extends TOutput = TOutput, TData = TQueryFnData>(input: StoreOrVal<EmptyToVoid<TInput>>, options: EdenDefinedCreateQueryOptions<TQueryFnData, TData, TError, TOutput>): EdenDefinedCreateQueryResult<TData, TError>;
    <TQueryFnData extends TOutput = TOutput, TData = TQueryFnData>(input: StoreOrVal<EmptyToVoid<TInput> | SkipToken>, options?: EdenCreateQueryOptions<TQueryFnData, TData, TError, TOutput>): EdenCreateQueryResult<TData, TError>;
}

type CreateQueryOptionsForCreateQueries<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = DistributiveOmit<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey'>;

/**
 * A function that accepts a callback that's called with a proxy object.
 * Invoking the proxy object returns strongly typed query options.
 */
type EdenTreatySvelteQueryCreateQueries<T extends AnyElysia> = <TData extends any[], TCombinedResult = QueriesResults<TData>>(callback: (t: EdenTreatySvelteQueryCreateQueriesProxy<T>) => readonly [...QueriesOptions<TData>]) => Readable<TCombinedResult>;
/**
 * RPC proxy derived from {@link AnyElysia._routes} that generates query options for `createQueries`.
 * This proxy is passed to the callback provided to the eden-treaty-svelte-query `createQueries` helper.
 */
type EdenTreatySvelteQueryCreateQueriesProxy<T extends AnyElysia> = T extends {
    _routes: infer TSchema extends Record<string, any>;
} ? EdenTreatySvelteQueryCreateQueriesProxyMapping<TSchema> : TypeError<'Please install Elysia before using Eden'>;
/**
 * Recursively iterate over all keys in {@link AnyElyisa._routes}, processing path parameters
 * and regular path segments separately.
 *
 * Regular path parameters will be mapped to a nested object, and then intersected
 * with anything generated by dynamic path parameters.
 *
 * @template TSchema The current level of {@link AnyElysia._routes} being processed.
 * @template TPath The current path segments up to this point (excluding dynamic path parameters).
 */
type EdenTreatySvelteQueryCreateQueriesProxyMapping<TSchema extends Record<string, any>, TPath extends any[] = [], TRouteParams = ExtractEdenTreatyRouteParams<TSchema>> = EdenTreatySvelteQueryCreateQueriesPathHooks<TSchema, TPath, TRouteParams> & EdenTreatySvelteQueryCreateQueriesPathParameterHook<TSchema, TPath, TRouteParams>;
/**
 * This intersects the object created by {@link EdenTreatySvelteQueryCreateQueriesPathHooks}
 * (for regular path parameters) to handle dynamic path parameters.
 *
 * If there are no dynamic path parameters, then return an empty object.
 * Intersecting with empty object does nothing.
 *
 * Otherwise, return a function that returns the next level of the proxy, omitting
 * the current dynamic path parameter.
 *
 * @template TSchema The current level of {@link AnyElysia._routes} being processed.
 * @template TPath The current path segments up to this point (excluding dynamic path parameters).
 * @template TRouteParams Keys that are considered path parameters instead of regular path segments.
 */
type EdenTreatySvelteQueryCreateQueriesPathParameterHook<TSchema extends Record<string, any>, TPath extends any[] = [], TRouteParams = {}> = {} extends TRouteParams ? {} : (params: ExtractEdenTreatyRouteParamsInput<TRouteParams>) => EdenTreatySvelteQueryCreateQueriesProxyMapping<TSchema[Extract<keyof TRouteParams, keyof TSchema>], TPath>;
/**
 * Recursively handle regular path segments (i.e. NOT path parameters).
 *
 * If the value is a {@link RouteSchema}, then it's a "leaf" that does not need to be
 * recursively processed. The result should be the key, an HTTP method, mapped to svelte-query hooks.
 *
 * @template TSchema The current level of {@link AnyElysia._routes} being processed.
 * @template TPath The current path segments up to this point (excluding dynamic path parameters).
 * @template TRouteParams Keys that are considered path parameters instead of regular path segments.
 */
type EdenTreatySvelteQueryCreateQueriesPathHooks<TSchema extends Record<string, any>, TPath extends any[] = [], TRouteParams = ExtractEdenTreatyRouteParams<TSchema>> = {
    [K in Exclude<keyof TSchema, keyof TRouteParams>]: TSchema[K] extends RouteSchema ? EdenTreatySvelteQueryCreateQueriesLeaf<TSchema[K], K, TPath> : EdenTreatySvelteQueryCreateQueriesProxyMapping<TSchema[K], [...TPath, K]>;
};
/**
 * When a {@link RouteSchema} is found, map it to leaves and stop recursive processing.
 * Based on the HTTP method, leaves may be functions that return {@link CreateQueryOptions}.
 *
 * @template TRoute The {@link RouteSchema} that was found.
 * @template TPath The current path segments up to this point (excluding dynamic path parameters).
 */
type EdenTreatySvelteQueryCreateQueriesLeaf<TRoute extends RouteSchema, TMethod, TPath extends any[] = []> = TMethod extends HttpQueryMethod ? EdenTreatySvelteQueryCreateQueriesQueryLeaf<TRoute, TPath> : TMethod extends HttpMutationMethod ? EdenTreatySvelteQueryCreateQueriesMutationLeaf<TRoute, TPath> : TMethod extends HttpSubscriptionMethod ? EdenTreatySvelteQueryCreateQueriesSubscriptionLeaf<TRoute, TPath> : EdenTreatySvelteQueryCreateQueriesUnknownLeaf<TRoute, TPath>;
/**
 * Routes that support queries, e.g. "GET" requests, will be mapped to a function that returns {@link CreateQueryOptions}.
 */
type EdenTreatySvelteQueryCreateQueriesQueryLeaf<TRoute extends RouteSchema, TPath extends any[] = [], TInput = InferRouteOptions<TRoute>['query'], TOutput = InferRouteOutput<TRoute>, TError = InferRouteError<TRoute>, TKey extends QueryKey = EdenQueryKey<TPath>> = (input: EmptyToVoid<TInput>, opts?: CreateQueryOptionsForCreateQueries<TOutput, TInput, TError>) => CreateQueryOptions<TOutput, TError, TOutput, TKey>;
/**
 * Routes that support mutations, e.g. anything besides "GET" requests, will be mapped to something unknown for now...
 *
 * @todo Decide what mutations should be mapped to...
 */
type EdenTreatySvelteQueryCreateQueriesMutationLeaf<_TRoute extends RouteSchema, _TPath extends any[] = []> = {};
/**
 * Routes that support queries, e.g. anything besides "GET" requests, will be mapped to something unknown for now...
 *
 * @todo Decide what subscriptions should be mapped to...
 */
type EdenTreatySvelteQueryCreateQueriesSubscriptionLeaf<_TRoute extends RouteSchema, _TPath extends any[] = []> = {};
/**
 * Routes that support unknown HTTP methods will be mapped to something unknown for now...
 *
 * @todo Decide what unknown methods should be mapped to...
 */
type EdenTreatySvelteQueryCreateQueriesUnknownLeaf<_TRoute extends RouteSchema, _TPath extends any[] = []> = {};
declare function createTreatySvelteQueryCreateQueriesProxy<T extends AnyElysia = AnyElysia>(client: EdenClient<T>, paths?: string[], config?: EdenQueryConfig<T>): EdenTreatySvelteQueryCreateQueriesProxy<T>;

type EdenTreatySvelteQueryUtils<TElysia extends AnyElysia, TSSRContext> = ProtectedIntersection<DecoratedEdenTreatySvelteQueryContextProps<TElysia, TSSRContext>, EdenTreatySvelteQueryUtilsProxy<TElysia['_routes']>>;
type DecoratedEdenTreatySvelteQueryContextProps<TElysia extends AnyElysia, TSSRContext> = Omit<EdenContextPropsBase<TElysia, TSSRContext>, 'client'> & {
    client: EdenTreatyClient<TElysia>;
};
type EdenTreatySvelteQueryContextProps<TElysia extends AnyElysia, TSSRContext> = EdenContextPropsBase<TElysia, TSSRContext> & {
    client: EdenClient<TElysia>;
};
type EdenTreatySvelteQueryUtilsProxy<TSchema extends Record<string, any>, TPath extends any[] = [], TRouteParams = ExtractEdenTreatyRouteParams<TSchema>> = EdenTreatyQueryUtilsUniversalUtils & {
    [K in keyof TSchema]: TSchema[K] extends RouteSchema ? EdenTreatyQueryUtilsMapping<TSchema[K], TPath, K> : EdenTreatySvelteQueryUtilsProxy<TSchema[K], [...TPath, K]>;
} & ({} extends TRouteParams ? {} : (params: ExtractEdenTreatyRouteParamsInput<TRouteParams>) => EdenTreatySvelteQueryUtilsProxy<TSchema[Extract<keyof TRouteParams, keyof TSchema>], TPath>);
type EdenTreatyQueryUtilsMapping<TRoute extends RouteSchema, TPath extends any[] = [], TMethod = '', TInput = InferRouteOptions<TRoute>['query']> = TMethod extends HttpQueryMethod ? EdenTreatyQueryUtilsQueryUtils<TRoute, TPath> & (InfiniteCursorKey extends keyof TInput ? EdenTreatyQueryUtilsInfiniteUtils<TRoute, TPath> : {}) : TMethod extends HttpMutationMethod ? EdenQueryUtilsMutationUtils<TRoute, TPath> : never;
type EdenTreatyQueryUtilsQueryUtils<TRoute extends RouteSchema, TPath extends any[] = [], TInput = InferRouteOptions<TRoute>['query'], TOutput = InferRouteOutput<TRoute>, TError = InferRouteError<TRoute>, TKey extends QueryKey = EdenQueryKey<TPath, TInput>> = {
    fetch: (input: EmptyToVoid<TInput>, options?: EdenFetchQueryOptions<TOutput, TError>) => Promise<TOutput>;
    prefetch: (input: EmptyToVoid<TInput>, options?: EdenFetchQueryOptions<TOutput, TError>) => Promise<void>;
    ensureData: (input: EmptyToVoid<TInput>, options?: EdenFetchQueryOptions<TOutput, TError>) => Promise<TOutput>;
    invalidate: (input?: DeepPartial<TInput>, filters?: Override<InvalidateQueryFilters, {
        predicate?: (query: Query<TInput, TError, TInput, TKey>) => boolean;
    }>, options?: InvalidateOptions) => Promise<void>;
    refetch: (input?: TInput, filters?: RefetchQueryFilters, options?: RefetchOptions) => Promise<void>;
    cancel: (input?: TInput, filters?: QueryFilters, options?: CancelOptions) => Promise<void>;
    reset: (input?: TInput, options?: ResetOptions) => Promise<void>;
    setData: (input: TInput, updater: Updater<TOutput | undefined, TOutput | undefined>, options?: SetDataOptions) => void;
    /**
     * @link https://tanstack.com/query/v5/docs/reference/QueryClient#queryclientsetquerydata
     */
    setQueriesData(input: TInput, filters: QueryFilters, updater: Updater<TOutput | undefined, TOutput | undefined>, options?: SetDataOptions): [QueryKey, TOutput];
    getData: (input: EmptyToVoid<TInput>) => TOutput | undefined;
    options: (input: EmptyToVoid<TInput>, options?: CreateQueryOptions<TOutput, TError>) => CreateQueryOptions<TOutput, TError>;
};
type EdenTreatyQueryUtilsInfiniteUtils<TRoute extends RouteSchema, TPath extends any[] = [], TInput = InferRouteOptions<TRoute, ReservedInfiniteQueryKeys>['query'], TOutput = InferRouteOutput<TRoute>, TError = InferRouteError<TRoute>, TKey extends QueryKey = EdenQueryKey<TPath, TInput>> = {
    fetchInfinite: (input: EmptyToVoid<TInput>, options?: EdenFetchInfiniteQueryOptions<TInput, TOutput, TError>) => Promise<InfiniteData<TOutput, NonNullable<ExtractCursorType<TInput>>>>;
    prefetchInfinite: (input: EmptyToVoid<TInput>, options?: EdenFetchQueryOptions<TOutput, TError>) => Promise<void>;
    getInfiniteData: (input: EmptyToVoid<TInput>) => InfiniteData<TOutput, NonNullable<ExtractCursorType<TInput>>> | undefined;
    setInfiniteData: (input: TInput, updater: Updater<InfiniteData<TOutput, NonNullable<ExtractCursorType<TInput>>> | undefined, InfiniteData<TOutput, NonNullable<ExtractCursorType<TInput>>> | undefined>, options?: SetDataOptions) => void;
    infiniteOptions: (input: EmptyToVoid<TInput>, options?: EdenCreateInfiniteQueryOptions<TInput, TOutput, TError>) => CreateInfiniteQueryOptions<TOutput, TError, TOutput, TKey>;
};
type EdenQueryUtilsMutationUtils<TRoute extends RouteSchema, TPath extends any[] = [], TBody = InferRouteBody<TRoute>, TOutput = InferRouteOutput<TRoute>, TError = InferRouteError<TRoute>, _TKey extends QueryKey = EdenQueryKey<TPath, TBody>> = {
    setMutationDefaults(options: EdenCreateMutationOptions<TBody, TError, TOutput> | ((args: {
        canonicalMutationFn: NonNullable<EdenCreateMutationOptions<TBody, TError, TOutput>['mutationFn']>;
    }) => EdenCreateMutationOptions<TBody, TError, TOutput>)): void;
    getMutationDefaults(): EdenCreateMutationOptions<TBody, TError, TOutput> | undefined;
    isMutating(): number;
};
/**
 * Utility hooks available at all levels of the utilities proxy.
 */
type EdenTreatyQueryUtilsUniversalUtils = {
    /**
     * Invalidate the full router
     * @link https://trpc.io/docs/v10/useContext#query-invalidation
     * @link https://tanstack.com/query/v5/docs/framework/react/guides/query-invalidation
     */
    invalidate(input?: undefined, filters?: InvalidateQueryFilters, options?: InvalidateOptions): Promise<void>;
};
declare function createEdenTreatyQueryUtils<TRouter extends AnyElysia, TSSRContext>(context: EdenContextState<TRouter, TSSRContext>, config?: EdenQueryConfig<TRouter>): EdenTreatySvelteQueryUtils<TRouter, TSSRContext>;
declare function mergeDehydrated(source: DehydratedState | QueryClient, destination: DehydratedState): DehydratedState;
declare function createEdenTreatyQueryUtilsProxy<TRouter extends AnyElysia, TSSRContext>(context: EdenContextState<TRouter, TSSRContext>, config?: EdenQueryConfig<TRouter>, originalPaths?: string[], pathParams?: Record<string, any>[]): EdenTreatySvelteQueryUtils<TRouter, TSSRContext>;

declare function createEdenTreatyQueryRootHooks<TElysia extends AnyElysia, TSSRContext = unknown, TError = EdenClientError<TElysia>>(config?: EdenQueryConfig<TElysia>): {
    createClient: EdenCreateClient<TElysia>;
    createHttpClient: (options?: HTTPLinkOptions) => EdenClient<AnyElysia>;
    createHttpBatchClient: (options?: HttpBatchLinkOptions) => EdenClient<AnyElysia>;
    createContext: (props: EdenContextProps<TElysia, TSSRContext>, configOverride?: EdenQueryConfig<TElysia> | undefined) => EdenContextState<TElysia, TSSRContext>;
    createUtils: (props: EdenContextProps<TElysia, TSSRContext>, configOverride?: EdenQueryConfig<TElysia> | undefined) => EdenTreatySvelteQueryUtils<TElysia, TSSRContext>;
    setContext: (props: EdenContextProps<TElysia, TSSRContext>, configOverride?: EdenQueryConfig<TElysia> | undefined) => EdenContextState<TElysia, TSSRContext>;
    getContext: (context?: EdenContextState<TElysia, TSSRContext>, configOverride?: EdenQueryConfig<TElysia> | undefined) => ProtectedIntersection<DecoratedEdenTreatySvelteQueryContextProps<TElysia, TSSRContext>, EdenTreatySvelteQueryUtilsProxy<TElysia["_routes"], [], _aydee_app_eden.ExtractEdenTreatyRouteParams<TElysia["_routes"]>>>;
    getUtils: (context?: EdenContextState<TElysia, TSSRContext>, configOverride?: EdenQueryConfig<TElysia> | undefined) => ProtectedIntersection<DecoratedEdenTreatySvelteQueryContextProps<TElysia, TSSRContext>, EdenTreatySvelteQueryUtilsProxy<TElysia["_routes"], [], _aydee_app_eden.ExtractEdenTreatyRouteParams<TElysia["_routes"]>>>;
    createQuery: (originalPaths: readonly string[], input?: StoreOrVal<InferRouteOptions | SkipToken>, options?: StoreOrVal<EdenCreateQueryOptions<unknown, unknown, TError>>) => EdenCreateQueryResult<unknown, TError>;
    createQueries: EdenTreatySvelteQueryCreateQueries<TElysia>;
    createMutation: (originalPaths: readonly string[], options?: StoreOrVal<EdenCreateMutationOptions<unknown, TError, unknown, unknown>>) => EdenCreateMutationResult<unknown, TError, unknown, unknown, unknown>;
    createInfiniteQuery: (originalPaths: readonly string[], input?: StoreOrVal<InferRouteOptions | SkipToken>, options?: StoreOrVal<EdenCreateInfiniteQueryOptions<unknown, unknown, TError>>) => EdenCreateInfiniteQueryResult<unknown, TError, unknown>;
};
type EdenTreatyQueryRootHooks<TElysia extends AnyElysia = AnyElysia, TSSRContext = unknown> = ReturnType<typeof createEdenTreatyQueryRootHooks<TElysia, TSSRContext>>;

type InferTreatyQueryIO<T extends AnyElysia> = T extends {
    _routes: infer TSchema extends Record<string, any>;
} ? InferTreatyQueryIOMapping<TSchema> : 'Please install Elysia before using Eden';
type InferTreatyQueryIOMapping<TSchema extends Record<string, any>, TPath extends any[] = []> = {
    [K in keyof TSchema]: TSchema[K] extends RouteSchema ? {
        input: K extends HttpQueryMethod ? InferRouteOptions<TSchema[K], Extract<K, string>> : [
            InferRouteBody<TSchema[K], Extract<K, string>>,
            InferRouteOptions<TSchema[K], Extract<K, string>>
        ];
        output: InferRouteOutput<TSchema[K]>;
    } : InferTreatyQueryIOMapping<TSchema[K], [...TPath, K]>;
};
type InferTreatyQueryInput<T extends AnyElysia> = T extends {
    _routes: infer TSchema extends Record<string, any>;
} ? InferTreatyQueryInputMapping<TSchema> : 'Please install Elysia before using Eden';
type InferTreatyQueryInputMapping<TSchema extends Record<string, any>, TPath extends any[] = []> = {
    [K in keyof TSchema]: TSchema[K] extends RouteSchema ? K extends HttpQueryMethod ? InferRouteOptions<TSchema[K], Extract<K, string>> : [
        InferRouteBody<TSchema[K], Extract<K, string>>,
        InferRouteOptions<TSchema[K], Extract<K, string>>
    ] : InferTreatyQueryInputMapping<TSchema[K], [...TPath, K]>;
};
type InferTreatyQueryOutput<T extends AnyElysia> = T extends {
    _routes: infer TSchema extends Record<string, any>;
} ? InferTreatyQueryOutputMapping<TSchema> : 'Please install Elysia before using Eden';
type InferTreatyQueryOutputMapping<TSchema extends Record<string, any>, TPath extends any[] = []> = {
    [K in keyof TSchema]: TSchema[K] extends RouteSchema ? InferRouteOutput<TSchema[K]> : InferTreatyQueryOutputMapping<TSchema[K], [...TPath, K]>;
};

/**
 * The treaty-query API provides utility methods that are available at the root, as well as
 * a strongly-typed proxy representing the {@link AnyElysia} API.
 */
type EdenTreatySvelteQuery<TElysia extends AnyElysia, TSSRContext> = EdenTreatySvelteQueryBase<TElysia, TSSRContext> & EdenTreatySvelteQueryHooks<TElysia>;
/**
 * Utilities available at the eden-treaty + svelte-query root.
 */
interface EdenTreatySvelteQueryBase<TElysia extends AnyElysia, TSSRContext> {
    /**
     * Get utilities provided via the context API.
     *
     * @see https://trpc.io/docs/v11/client/react/useUtils
     */
    getUtils(): EdenTreatySvelteQueryUtils<TElysia, TSSRContext>;
    /**
     * Get utilities provided via the context API.
     *
     * @deprecated renamed to {@link getUtils} and will be removed in a future tRPC version
     *
     * @see https://trpc.io/docs/v11/client/react/useUtils
     */
    getContext(): EdenTreatySvelteQueryUtils<TElysia, TSSRContext>;
    /**
     * Returns everything that will be provided from context.
     *
     * e.g. the root utility functions, and root configuration settings.
     */
    createContext(props: EdenContextProps<TElysia, TSSRContext>, config?: EdenQueryConfig<TElysia>): EdenContextState<TElysia, TSSRContext>;
    /**
     * Creates a proxy that can invoke tanstack-query helper functions.
     */
    createUtils(props: EdenContextProps<TElysia, TSSRContext>, config?: EdenQueryConfig<TElysia>): EdenTreatySvelteQueryUtils<TElysia, TSSRContext>;
    /**
     * Create utilities and provide them via context.
     */
    setContext(props: EdenContextProps<TElysia, TSSRContext>, config?: EdenQueryConfig<TElysia>): EdenContextState<TElysia, TSSRContext>;
    /**
     * Wraps the `create-queries` svelte-query hook in a type-safe proxy.
     */
    createQueries: EdenTreatySvelteQueryCreateQueries<TElysia>;
    /**
     * Create a raw, untyped-client.
     */
    createClient: EdenCreateClient<TElysia>;
    /**
     * Convenience method for creating and configuring a client with a single HTTPLink.
     */
    createHttpClient: (options?: HTTPLinkOptions<TElysia>) => EdenClient<TElysia>;
    /**
     * Convenience method for creating and configuring a client with a single HttpBatchLink.
     */
    createHttpBatchClient: (options?: HttpBatchLinkOptions<TElysia>) => EdenClient<TElysia>;
}
/**
 * RPC proxy derived from {@link AnyElysia._routes} that connects svelte-query with an Elysia.js API.
 */
type EdenTreatySvelteQueryHooks<T extends AnyElysia> = T extends {
    _routes: infer TSchema extends Record<string, any>;
} ? EdenTreatySvelteQueryHooksProxy<TSchema> : TypeError<'Please install Elysia before using Eden'>;
/**
 * Recursively iterate over all keys in {@link AnyElyisa._routes}, processing path parameters
 * and regular path segments separately.
 *
 * Regular path parameters will be mapped to a nested object, and then intersected
 * with anything generated by dynamic path parameters.
 *
 * @template TSchema The current level of {@link AnyElysia._routes} being processed.
 * @template TPath The current path segments up to this point (excluding dynamic path parameters).
 * @template TRouteParams Keys that are considered path parameters instead of regular path segments.
 */
type EdenTreatySvelteQueryHooksProxy<TSchema extends Record<string, any>, TPath extends any[] = [], TRouteParams = ExtractEdenTreatyRouteParams<TSchema>> = EdenTreatySvelteQueryPathHooks<TSchema, TPath, TRouteParams> & EdenTreatySvelteQueryHooksPathParameterHook<TSchema, TPath, TRouteParams>;
/**
 * Recursively handle regular path segments (i.e. NOT path parameters).
 *
 * If the value is a {@link RouteSchema}, then it's a "leaf" that does not need to be
 * recursively processed. The result should be the key, an HTTP method, mapped to svelte-query hooks.
 *
 * @template TSchema The current level of {@link AnyElysia._routes} being processed.
 * @template TPath The current path segments up to this point (excluding dynamic path parameters).
 * @template TRouteParams Keys that are considered path parameters instead of regular path segments.
 */
type EdenTreatySvelteQueryPathHooks<TSchema extends Record<string, any>, TPath extends any[] = [], TRouteParams = ExtractEdenTreatyRouteParams<TSchema>> = {
    [K in Exclude<keyof TSchema, keyof TRouteParams>]: TSchema[K] extends RouteSchema ? EdenTreatySvelteQueryRouteLeaf<TSchema[K], K, TPath> : EdenTreatySvelteQueryHooksProxy<TSchema[K], [...TPath, K]>;
};
/**
 * This intersects the object created by {@link EdenTreatyPathHooks}
 * (for regular path parameters) to handle dynamic path parameters.
 *
 * If there are no dynamic path parameters, then return an empty object.
 * Intersecting with empty object does nothing.
 *
 * Otherwise, return a function that returns the next level of the proxy, omitting
 * the current dynamic path parameter.
 *
 * @template TSchema The current level of {@link AnyElysia._routes} being processed.
 * @template TPath The current path segments up to this point (excluding dynamic path parameters).
 * @template TRouteParams Keys that are considered path parameters instead of regular path segments.
 */
type EdenTreatySvelteQueryHooksPathParameterHook<TSchema extends Record<string, any>, TPath extends any[] = [], TRouteParams = {}> = {} extends TRouteParams ? {} : (params: StoreOrVal<ExtractEdenTreatyRouteParamsInput<TRouteParams>>) => EdenTreatySvelteQueryHooksProxy<TSchema[Extract<keyof TRouteParams, keyof TSchema>], TPath>;
/**
 * When a {@link RouteSchema} is found, map it to leaves and stop recursive processing.
 * Leaves are objects with svelte-query hooks related to the HTTP method.
 *
 * For example, the object would contain hooks for queries if {@link TMethod} was "get".
 *
 * @template TRoute The {@link RouteSchema} that was found.
 * @template TMethod The most recent key that was mapped to the {@link TRoute}. e.g. "get", "post", etc.
 * @template TPath The current path segments up to this point (excluding dynamic path parameters).
 */
type EdenTreatySvelteQueryRouteLeaf<TRoute extends RouteSchema, TMethod, TPath extends any[] = []> = TMethod extends HttpQueryMethod ? EdenTreatySvelteQueryLeaf<TRoute, TPath> : TMethod extends HttpMutationMethod ? EdenTreatySvelteQueryMutationLeaf<TRoute, TPath> : TMethod extends HttpSubscriptionMethod ? EdenTreatySvelteQuerySubscriptionLeaf<TRoute, TPath> : EdenTreatySvelteQueryUnknownLeaf<TRoute, TPath>;
/**
 * svelte-query hooks for "queries". e.g. routes with a "GET" endpoint.
 */
type EdenTreatySvelteQueryLeaf<TRoute extends RouteSchema, TPath extends any[] = [], TInput extends InferRouteOptions<TRoute> = InferRouteOptions<TRoute>> = {
    createQuery: EdenCreateQuery<TRoute, TPath>;
} & (InfiniteCursorKey extends keyof (TInput['params'] & TInput['query']) ? EdenTreatySvelteQueryInfiniteQueryLeaf<TRoute, TPath> : {});
/**
 * svelte-query hooks for "infinite-queries".
 * e.g. routes with a "GET" endpoint that also expects "cursor" as a query parameter.
 */
type EdenTreatySvelteQueryInfiniteQueryLeaf<TRoute extends RouteSchema, TPath extends any[] = []> = {
    createInfiniteQuery: EdenCreateInfiniteQuery<TRoute, TPath>;
};
/**
 * svelte-query hooks for "mutations". e.g. Basically routes with any HTTP methods other than "GET."
 */
type EdenTreatySvelteQueryMutationLeaf<TRoute extends RouteSchema, TPath extends any[] = []> = {
    createMutation: EdenCreateMutation<TRoute, TPath>;
};
/**
 * @todo: svelte-query hooks for "subscriptions". e.g. Basically routes that support "CONNECT" or "SUBSCRIBE" requests.
 *
 * @see https://github.com/trpc/trpc/blob/52a57eaa9c12394778abf5f0e6b52ec6f46288ed/packages/react-query/src/shared/hooks/createHooksInternal.tsx#L347
 * @see https://tkdodo.eu/blog/using-web-sockets-with-react-query
 */
type EdenTreatySvelteQuerySubscriptionLeaf<TRoute extends RouteSchema, TPath extends any[] = [], TInput = InferRouteOptions<TRoute>> = {
    options: Prettify<EdenRequestOptions & TInput>;
    queryKey: EdenQueryKey<TPath>;
};
/**
 * svelte-query hooks for any unknown HTTP methods will just expose all known hooks for now.
 *
 * @todo Decide what hooks to expose...
 */
type EdenTreatySvelteQueryUnknownLeaf<TRoute extends RouteSchema, TPath extends any[] = []> = EdenTreatySvelteQueryLeaf<TRoute, TPath> & EdenTreatySvelteQueryInfiniteQueryLeaf<TRoute, TPath> & EdenTreatySvelteQueryMutationLeaf<TRoute, TPath> & EdenTreatySvelteQuerySubscriptionLeaf<TRoute, TPath>;
/**
 * Main entrypoint for this library.
 *
 * @param config Default configuration for the root hooks.
 */
declare function createEdenTreatySvelteQuery<TElysia extends AnyElysia, TSSRContext = unknown>(config?: EdenQueryConfig<TElysia>): EdenTreatySvelteQuery<TElysia, TSSRContext>;
/**
 * Creates the recursive proxy.
 *
 * @param config Root hooks that were created.
 *
 * @param rootHooks The original configuration for eden-treaty.
 *
 * @param paths Path parameter strings including the current path parameter as a placeholder.
 *  @example [ 'products', ':id', ':cursor' ]
 *
 * @param pathParams An array of objects representing path parameter replacements.
 * @example [ { id: 123 }, writable({ cursor: '456' }) ]
 */
declare function createEdenTreatySvelteQueryProxy<T extends AnyElysia = AnyElysia>(rootHooks: EdenTreatyQueryRootHooks<T>, config?: EdenQueryConfig<T>, paths?: (string | symbol)[], pathParams?: StoreOrVal<Record<string, any>>[]): () => void;
declare const routeDefinitionSymbol: unique symbol;
/**
 * Get a query key by providing the proxy at any level.
 */
declare function getQueryKey<TSchema extends Record<string, any>>(route: EdenTreatySvelteQueryHooksProxy<TSchema>, input?: TSchema extends RouteSchema ? InferRouteOptions<TSchema> : any, type?: EdenQueryType): EdenQueryKey;
/**
 * Get a mutation key by providing the proxy at any level.
 */
declare function getMutationKey<TSchema extends RouteSchema>(route: EdenTreatySvelteQueryHooksProxy<TSchema>, options?: EdenQueryKeyOptions): EdenMutationKey;

export { type DecoratedEdenTreatySvelteQueryContextProps, type EdenQueryUtilsMutationUtils, type EdenTreatyQueryRootHooks, type EdenTreatyQueryUtilsInfiniteUtils, type EdenTreatyQueryUtilsQueryUtils, type EdenTreatyQueryUtilsUniversalUtils, type EdenTreatySvelteQuery, type EdenTreatySvelteQueryBase, type EdenTreatySvelteQueryContextProps, type EdenTreatySvelteQueryCreateQueries, type EdenTreatySvelteQueryCreateQueriesLeaf, type EdenTreatySvelteQueryCreateQueriesMutationLeaf, type EdenTreatySvelteQueryCreateQueriesPathHooks, type EdenTreatySvelteQueryCreateQueriesProxy, type EdenTreatySvelteQueryCreateQueriesProxyMapping, type EdenTreatySvelteQueryCreateQueriesQueryLeaf, type EdenTreatySvelteQueryCreateQueriesSubscriptionLeaf, type EdenTreatySvelteQueryCreateQueriesUnknownLeaf, type EdenTreatySvelteQueryHooks, type EdenTreatySvelteQueryHooksPathParameterHook, type EdenTreatySvelteQueryHooksProxy, type EdenTreatySvelteQueryInfiniteQueryLeaf, type EdenTreatySvelteQueryLeaf, type EdenTreatySvelteQueryMutationLeaf, type EdenTreatySvelteQueryPathHooks, type EdenTreatySvelteQueryRouteLeaf, type EdenTreatySvelteQuerySubscriptionLeaf, type EdenTreatySvelteQueryUnknownLeaf, type EdenTreatySvelteQueryUtils, type EdenTreatySvelteQueryUtilsProxy, type InferTreatyQueryIO, type InferTreatyQueryIOMapping, type InferTreatyQueryInput, type InferTreatyQueryInputMapping, type InferTreatyQueryOutput, type InferTreatyQueryOutputMapping, createEdenTreatyQueryRootHooks, createEdenTreatyQueryUtils, createEdenTreatyQueryUtilsProxy, createEdenTreatySvelteQuery, createEdenTreatySvelteQueryProxy, createTreatySvelteQueryCreateQueriesProxy, getMutationKey, getQueryKey, mergeDehydrated, routeDefinitionSymbol };