import * as _aydee_app_eden from '@aydee-app/eden';
import { EdenRequestOptions, InferRouteOptions, EdenClient, EdenClientError, InferRouteOutput, InferRouteError, EmptyToVoid, InferRouteBody, EdenTreatyClient, ExtractEdenTreatyRouteParams, HttpQueryMethod, HttpMutationMethod, ExtractEdenTreatyRouteParamsInput, EdenCreateClient, HTTPLinkOptions, HttpBatchLinkOptions, HttpSubscriptionMethod } from '@aydee-app/eden';
export * from '@aydee-app/eden';
import { AnyElysia, MaybePromise, RouteSchema } from 'elysia';
import { Prettify } from 'elysia/types';
import * as _tanstack_react_query from '@tanstack/react-query';
import { QueryClient, FetchInfiniteQueryOptions, FetchQueryOptions, InfiniteData, InvalidateQueryFilters, InvalidateOptions, QueryFilters, ResetOptions, RefetchQueryFilters, RefetchOptions, CancelOptions, Updater, SetDataOptions, QueryKey, MutationOptions, UseInfiniteQueryOptions, UseInfiniteQueryResult, SkipToken, UseMutationOptions, UseBaseMutationResult, MutateOptions, UseBaseQueryOptions, UseQueryResult, InitialDataFunction, DefinedUseQueryResult, UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult, UseSuspenseQueryOptions, UseSuspenseQueryResult, Query, UseQueryOptions, QueriesResults, QueriesOptions, SuspenseQueriesOptions } from '@tanstack/react-query';
import * as React$1 from 'react';

/**
 * 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.
     *
     * @todo
     *
     * This should actually be renamed based on {@see https://github.com/trpc/trpc/issues/4448}.
     *
     * TLDR:
     * This property actually means "forward the queryFn's context.signal",
     * which has __more__ functionality than simply aborting the request.
     */
    abortOnUnmount?: boolean;
    /**
     * Opt out of SSR for this query by passing `ssr: false`.
     */
    ssr?: boolean;
    /**
     * Overrides for svelte-query hooks.
     */
    overrides?: EdenQueryOverrides;
};
/**
 * Top-level overrides applied to the generated eden-query hooks.
 */
type EdenQueryOverrides = {
    /**
     * Override the default options provided to `useMutation`.
     */
    useMutation?: Partial<UseMutationOverrides>;
};
/**
 * Default props that can be provided to the generated `useMutation` hooks.
 */
type UseMutationOverrides = {
    onSuccess: (options: UseMutationOverridesOnSuccessOptions) => MaybePromise<unknown>;
};
type UseMutationOverridesOnSuccessOptions = {
    /**
     * Calls the original function that was defined in the query's `onSuccess` option
     */
    originalFn: () => MaybePromise<unknown>;
    queryClient: QueryClient;
    /**
     * Meta data passed in from the `useMutation()` hook
     */
    meta: Record<string, unknown>;
};

type EdenQueryConfig<T extends AnyElysia = AnyElysia> = EdenQueryRequestOptions<T> & {
    /**
     * Override the default context provider
     * @default undefined
     */
    context?: React.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;

/**
 * @internal
 */
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;
};
type SSRState = 'mounted' | 'mounting' | 'prepass' | false;
type EdenContextPropsBase<TElysia extends AnyElysia, TSSRContext> = {
    /**
     * The `TRPCClient`
     */
    client: EdenClient<TElysia>;
    /**
     * The SSR context when server-side rendering
     * @default null
     */
    ssrContext?: TSSRContext | null;
    /**
     * State of SSR hydration.
     * - `false` if not using SSR.
     * - `prepass` when doing a prepass to fetch queries' data
     * - `mounting` before TRPCProvider has been rendered on the client
     * - `mounted` when the TRPCProvider has been rendered on the client
     * @default false
     */
    ssrState?: SSRState;
    /**
     * @deprecated pass abortOnUnmount to `createTRPCReact` instead
     * Abort loading query calls when unmounting a component - usually when navigating to a new page
     * @default false
     */
    abortOnUnmount?: boolean;
};
type EdenProviderProps<TRouter extends AnyElysia, TSSRContext> = EdenContextProps<TRouter, TSSRContext> & {
    children: React$1.ReactNode;
};
type EdenProvider<TRouter extends AnyElysia, TSSRContext> = (props: EdenProviderProps<TRouter, TSSRContext>) => React$1.JSX.Element;
type EdenContextProps<TRouter extends AnyElysia, TSSRContext> = EdenContextPropsBase<TRouter, TSSRContext> & {
    /**
     * The react-query `QueryClient`
     */
    queryClient: QueryClient;
};
type EdenContextState<TRouter extends AnyElysia, TSSRContext = undefined> = Required<EdenContextProps<TRouter, TSSRContext>> & EdenQueryUtils<TRouter>;

/**
 * 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 EdenUseInfiniteQueryOptions<TInput, TOutput, TError> extends DistributiveOmit<UseInfiniteQueryOptions<TOutput, TError, TOutput, any, ExtractQueryCursor<TInput>>, 'queryKey' | 'initialPageParam'>, EdenQueryBaseOptions {
    initialCursor?: ExtractQueryCursor<TInput>;
}
type EdenUseInfiniteQueryResult<TData, TError, TInput> = WithEdenQueryExtension<UseInfiniteQueryResult<InfiniteData<TData, NonNullable<ExtractQueryCursor<TInput>> | null>, TError>>;
type EdenUseInfiniteQuery<TRoute extends RouteSchema, _TPath extends any[] = [], TInput = InferRouteOptions<TRoute>['query'], TOutput = InferRouteOutput<TRoute>, TError = InferRouteError<TRoute>, TInfiniteInput = InferRouteOptions<TRoute, ReservedInfiniteQueryKeys>['query']> = (input: EmptyToVoid<TInfiniteInput> | SkipToken, options: EdenUseInfiniteQueryOptions<TInput, TOutput, TError>) => EdenUseInfiniteQueryResult<TOutput, TError, TInput>;

type EdenUseMutationOptions<TInput, TError, TOutput, TContext = unknown> = UseMutationOptions<TOutput, TError, TInput, TContext> & EdenQueryBaseOptions;
type EdenUseMutationResult<TData, TError, TVariables, TContext, TInput> = WithEdenQueryExtension<Override<UseBaseMutationResult<TData, TError, TVariables, TContext>, {
    mutateAsync: EdenAsyncMutationFunction<TData, TError, TVariables, TInput>;
    mutate: EdenMutationFunction<TData, TError, TVariables, TInput>;
}>>;
type EdenUseMutation<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?: EdenUseMutationOptions<TVariables, TError, TData, TContext>) => EdenUseMutationResult<TData, TError, TVariables, TContext, TInput>;
type EdenAsyncMutationFunction<TData, TError, TVariables, TInput> = <TContext = TData>(variables: {} extends TVariables ? void : unknown extends TVariables ? void : TVariables, options: {} extends TInput ? void | (TInput & MutateOptions<TData, TError, EdenUseMutationVariables<TVariables, TInput>, TContext>) : TInput & MutateOptions<TData, TError, EdenUseMutationVariables<TVariables, TInput>, TContext>) => Promise<TData>;
type EdenMutationFunction<TData, TError, TVariables, TInput> = <TContext = unknown>(variables: {} extends TVariables ? void : unknown extends TVariables ? void : TVariables, options: {} extends TInput ? void | (TInput & MutateOptions<TData, TError, EdenUseMutationVariables<TVariables, TInput>, TContext>) : TInput & MutateOptions<TData, TError, EdenUseMutationVariables<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 EdenUseMutationVariables<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 EdenUseQueryOptions<TOutput, TData, TError, TQueryOptsData = TOutput> = DistributiveOmit<UseBaseQueryOptions<TOutput, TError, TData, TQueryOptsData, any>, 'queryKey'> & EdenQueryBaseOptions;
type EdenDefinedUseQueryOptions<TOutput, TData, TError, TQueryOptsData = TOutput> = DistributiveOmit<UseBaseQueryOptions<TOutput, TError, TData, TQueryOptsData, any>, 'queryKey'> & EdenQueryBaseOptions & {
    initialData: InitialDataFunction<TQueryOptsData> | TQueryOptsData;
};
type EdenUseQueryResult<TData, TError> = WithEdenQueryExtension<UseQueryResult<TData, TError>>;
type EdenDefinedUseQueryResult<TData, TError> = WithEdenQueryExtension<DefinedUseQueryResult<TData, TError>>;
interface EdenUseQuery<TRoute extends RouteSchema, _TPath extends any[] = [], TInput = InferRouteOptions<TRoute>['query'], TOutput = InferRouteOutput<TRoute>, TError = InferRouteError<TRoute>> {
    <TQueryFnData extends TOutput = TOutput, TData = TQueryFnData>(input: EmptyToVoid<TInput>, options: EdenDefinedUseQueryOptions<TQueryFnData, TData, TError, TOutput>): EdenDefinedUseQueryResult<TData, TError>;
    <TQueryFnData extends TOutput = TOutput, TData = TQueryFnData>(input: EmptyToVoid<TInput> | SkipToken, options?: EdenUseQueryOptions<TQueryFnData, TData, TError, TOutput>): EdenUseQueryResult<TData, TError>;
}

interface EdenUseSuspenseInfiniteQueryOptions<TInput, TOutput, TError> extends DistributiveOmit<UseSuspenseInfiniteQueryOptions<TOutput, TError, TOutput, any, ExtractCursorType<TInput>>, 'queryKey' | 'initialPageParam'>, EdenQueryBaseOptions {
    initialCursor?: ExtractCursorType<TInput>;
}
/**
 * @internal
 */
type EdenUseSuspenseInfiniteQueryResult<TData, TError, TInput> = [
    InfiniteData<TData, NonNullable<ExtractCursorType<TInput>> | null>,
    WithEdenQueryExtension<UseSuspenseInfiniteQueryResult<InfiniteData<TData, NonNullable<ExtractCursorType<TInput>> | null>, TError>>
];
type EdenUseSuspenseInfiniteQuery<TRoute extends RouteSchema, _TPath extends any[] = [], TInput = InferRouteOptions<TRoute>['query'], TOutput = InferRouteOutput<TRoute>, TError = InferRouteError<TRoute>> = (input: EmptyToVoid<TInput>, options?: EdenUseSuspenseInfiniteQueryOptions<TOutput, TOutput, TError>) => EdenUseSuspenseInfiniteQueryResult<TOutput, TError, TInput>;

interface EdenUseSuspenseQueryOptions<TOutput, TData, TError> extends DistributiveOmit<UseSuspenseQueryOptions<TOutput, TError, TData, any>, 'queryKey'>, EdenQueryBaseOptions {
}
/**
 * @internal
 */
type EdenUseSuspenseQueryResult<TData, TError> = [
    TData,
    WithEdenQueryExtension<UseSuspenseQueryResult<TData, TError>>
];
type EdenUseSuspenseQuery<TRoute extends RouteSchema, _TPath extends any[] = [], TInput = InferRouteOptions<TRoute>['query'], TOutput = InferRouteOutput<TRoute>, TError = InferRouteError<TRoute>> = (input: EmptyToVoid<TInput>, options?: EdenUseSuspenseQueryOptions<TOutput, TOutput, TError>) => EdenUseSuspenseQueryResult<TOutput, TError>;

type EdenTreatyReactQueryUtils<TElysia extends AnyElysia, TSSRContext> = ProtectedIntersection<DecoratedEdenTreatyReactQueryContextProps<TElysia, TSSRContext>, EdenTreatyReactQueryUtilsProxy<TElysia['_routes']>>;
type DecoratedEdenTreatyReactQueryContextProps<TElysia extends AnyElysia, TSSRContext> = Omit<EdenContextPropsBase<TElysia, TSSRContext>, 'client'> & {
    client: EdenTreatyClient<TElysia>;
};
type EdenTreatyReactQueryContextProps<TElysia extends AnyElysia, TSSRContext> = EdenContextPropsBase<TElysia, TSSRContext> & {
    client: EdenClient<TElysia>;
};
type EdenTreatyReactQueryUtilsProxy<TSchema extends Record<string, any>, TPath extends any[] = [], TRouteParams = ExtractEdenTreatyRouteParams<TSchema>> = EdenTreatyQueryUtilsUniversalUtils & {
    [K in keyof TSchema]: TSchema[K] extends RouteSchema ? EdenTreatyReactQueryUtilsMapping<TSchema[K], TPath, K> : EdenTreatyReactQueryUtilsProxy<TSchema[K], [...TPath, K]>;
} & ({} extends TRouteParams ? {} : (params: ExtractEdenTreatyRouteParamsInput<TRouteParams>) => EdenTreatyReactQueryUtilsProxy<TSchema[Extract<keyof TRouteParams, keyof TSchema>], TPath>);
type EdenTreatyReactQueryUtilsMapping<TRoute extends RouteSchema, TPath extends any[] = [], TMethod = '', TInput extends InferRouteOptions<TRoute> = InferRouteOptions<TRoute>> = TMethod extends HttpQueryMethod ? EdenTreatyQueryUtilsQueryUtils<TRoute, TPath> & (InfiniteCursorKey extends keyof (TInput['params'] & TInput['query']) ? EdenTreatyQueryUtilsInfiniteUtils<TRoute, TPath> : {}) : TMethod extends HttpMutationMethod ? EdenQueryUtilsMutationUtils<TRoute, TPath> : `Unknown HTTP Method: ${TMethod & string}`;
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?: UseQueryOptions<TOutput, TError>) => UseQueryOptions<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?: EdenUseInfiniteQueryOptions<TInput, TOutput, TError>) => UseInfiniteQueryOptions<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: EdenUseMutationOptions<TBody, TError, TOutput> | ((args: {
        canonicalMutationFn: NonNullable<EdenUseMutationOptions<TBody, TError, TOutput>['mutationFn']>;
    }) => EdenUseMutationOptions<TBody, TError, TOutput>)): void;
    getMutationDefaults(): EdenUseMutationOptions<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>): EdenTreatyReactQueryUtils<TRouter, TSSRContext>;
/**
 * @todo use config for something...
 */
declare function createEdenTreatyQueryUtilsProxy<TRouter extends AnyElysia, TSSRContext>(context: EdenContextState<TRouter, TSSRContext>, config?: EdenQueryConfig<TRouter>, originalPaths?: string[], pathParams?: Record<string, any>[]): EdenTreatyReactQueryUtils<TRouter, TSSRContext>;

/**
 * @todo Eden-subscription?
 */
interface EdenUseSubscriptionOptions<TOutput, TError> {
    enabled?: boolean;
    onStarted?: () => void;
    onData: (data: TOutput) => void;
    onError?: (err: TError) => void;
}

type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = DistributiveOmit<UseQueryOptions<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 EdenTreatyUseQueries<T extends AnyElysia> = <TData extends any[], TCombinedResult = QueriesResults<TData>>(callback: (t: EdenTreatyUseQueriesProxy<T>) => readonly [...QueriesOptions<TData>]) => TCombinedResult;
/**
 * A proxy object that returns {@link CreateQueryOptions} (instead of an actual create query result).
 * Passed to `createQueries` caller to use.
 */
type EdenTreatyUseQueriesProxy<T extends AnyElysia> = T extends {
    _routes: infer TSchema extends Record<string, any>;
} ? EdenTreatyUseQueriesProxyMapping<TSchema> : 'Please install Elysia before using Eden';
/**
 * Implementation.
 */
type EdenTreatyUseQueriesProxyMapping<TSchema extends Record<string, any>, TPath extends any[] = [], TRouteParams = ExtractEdenTreatyRouteParams<TSchema>> = {
    [K in Exclude<keyof TSchema, keyof TRouteParams>]: TSchema[K] extends RouteSchema ? EdenTreatyUseQueriesHook<TSchema[K], [...TPath, K]> : EdenTreatyUseQueriesProxyMapping<TSchema[K], [...TPath, K]>;
} & ({} extends TRouteParams ? {} : (params: ExtractEdenTreatyRouteParamsInput<TRouteParams>) => EdenTreatyUseQueriesProxyMapping<TSchema[Extract<keyof TRouteParams, keyof TSchema>], TPath>);
/**
 * When a route is encountered, it is replaced with a callable function that takes the same inputs.
 */
type EdenTreatyUseQueriesHook<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?: UseQueryOptionsForUseQueries<TOutput, TInput, TError>) => UseQueryOptions<TOutput, TError, TOutput, TKey>;
declare function createTreatyUseQueriesProxy<T extends AnyElysia = AnyElysia>(client: EdenClient<T>, originalPaths?: string[], config?: EdenQueryConfig<T>, pathParams?: Record<string, any>[]): EdenTreatyUseQueriesProxy<T>;

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

type EdenTreatyUseSuspenseQueries<T extends AnyElysia> = <TData extends any[], TQueriesOptions extends SuspenseQueriesOptions<TData>>(queriesCallback: (t: EdenTreatyUseSuspenseQueriesProxy<T>) => readonly [...TQueriesOptions]) => UseSuspenseQueriesResult<TQueriesOptions>;
/**
 * A proxy object that returns {@link CreateQueryOptions} (instead of an actual create query result).
 * Passed to `createQueries` caller to use.
 */
type EdenTreatyUseSuspenseQueriesProxy<T extends AnyElysia> = T extends {
    _routes: infer TSchema extends Record<string, any>;
} ? EdenTreatyUseSuspenseQueriesProxyMapping<TSchema> : 'Please install Elysia before using Eden';
type EdenTreatyUseSuspenseQueriesProxyMapping<TSchema extends Record<string, any>, TPath extends any[] = [], TRouteParams = ExtractEdenTreatyRouteParams<TSchema>> = {
    [K in Exclude<keyof TSchema, keyof TRouteParams>]: TSchema[K] extends RouteSchema ? UseSuspenseQueriesHook<TSchema[K], [...TPath, K]> : EdenTreatyUseSuspenseQueriesProxyMapping<TSchema[K], [...TPath, K]>;
} & ({} extends TRouteParams ? {} : (params: ExtractEdenTreatyRouteParamsInput<TRouteParams>) => EdenTreatyUseSuspenseQueriesProxyMapping<TSchema[Extract<keyof TRouteParams, keyof TSchema>], TPath>);
/**
 * When a route is encountered, it is replaced with a callable function that takes the same inputs.
 */
type UseSuspenseQueriesHook<TRoute extends RouteSchema, _TPath extends any[] = [], TInput = InferRouteOptions<TRoute>['query'], TOutput = InferRouteOutput<TRoute>, TError = InferRouteError<TRoute>> = (input: EmptyToVoid<TInput>, opts?: UseQueryOptionsForUseSuspenseQueries<TOutput, TError>) => UseQueryOptionsForUseSuspenseQueries<TOutput, TError>;
declare function createTreatyUseSuspenseQueriesProxy<T extends AnyElysia = AnyElysia>(client: EdenClient<T>, paths?: string[]): EdenTreatyUseSuspenseQueriesProxy<T>;
type UseSuspenseQueriesResult<TQueriesOptions extends UseQueryOptionsForUseSuspenseQueries<any, any, any, any>[]> = [
    {
        [TKey in keyof TQueriesOptions]: TQueriesOptions[TKey] extends UseQueryOptionsForUseSuspenseQueries<infer TQueryFnData, any, infer TData, any> ? unknown extends TData ? TQueryFnData : TData : never;
    },
    {
        [TKey in keyof TQueriesOptions]: TQueriesOptions[TKey] extends UseQueryOptionsForUseSuspenseQueries<infer TQueryFnData, infer TError, infer TData, any> ? UseSuspenseQueryResult<unknown extends TData ? TQueryFnData : TData, TError> : never;
    }
];

declare function createEdenTreatyQueryRootHooks<TElysia extends AnyElysia, TSSRContext = unknown, TError = EdenClientError<TElysia>>(config?: EdenQueryConfig<TElysia>): {
    Provider: EdenProvider<TElysia, TSSRContext>;
    createClient: EdenCreateClient<TElysia>;
    createHttpClient: (options?: HTTPLinkOptions) => EdenClient<AnyElysia>;
    createHttpBatchClient: (options?: HttpBatchLinkOptions) => EdenClient<AnyElysia>;
    createContext: (props: EdenContextProps<TElysia, TSSRContext>) => {
        fetchQuery: (queryKey: EdenQueryKey, opts?: EdenFetchQueryOptions<unknown, EdenClientError<TElysia>>) => Promise<unknown>;
        fetchInfiniteQuery: (queryKey: EdenQueryKey, opts?: EdenFetchInfiniteQueryOptions<unknown, unknown, EdenClientError<TElysia>>) => Promise<_tanstack_react_query.InfiniteData<unknown, unknown>>;
        prefetchQuery: (queryKey: EdenQueryKey, opts?: EdenFetchQueryOptions<unknown, EdenClientError<TElysia>>) => Promise<void>;
        prefetchInfiniteQuery: (queryKey: EdenQueryKey, opts?: EdenFetchInfiniteQueryOptions<unknown, unknown, EdenClientError<TElysia>>) => Promise<void>;
        ensureQueryData: (queryKey: EdenQueryKey, opts?: EdenFetchQueryOptions<unknown, EdenClientError<TElysia>>) => Promise<unknown>;
        invalidateQueries: (queryKey: EdenQueryKey, filters?: _tanstack_react_query.InvalidateQueryFilters, options?: _tanstack_react_query.InvalidateOptions) => Promise<void>;
        resetQueries: (queryKey: EdenQueryKey, filters?: _tanstack_react_query.QueryFilters, options?: _tanstack_react_query.ResetOptions) => Promise<void>;
        refetchQueries: (queryKey: EdenQueryKey, filters?: _tanstack_react_query.RefetchQueryFilters, options?: _tanstack_react_query.RefetchOptions) => Promise<void>;
        cancelQuery: (queryKey: EdenQueryKey, options?: _tanstack_react_query.CancelOptions) => Promise<void>;
        setQueryData: (queryKey: EdenQueryKey, updater: _tanstack_react_query.Updater<unknown, unknown>, options?: _tanstack_react_query.SetDataOptions) => void;
        setQueriesData: (queryKey: EdenQueryKey, filters: _tanstack_react_query.QueryFilters, updater: _tanstack_react_query.Updater<unknown, unknown>, options?: _tanstack_react_query.SetDataOptions) => [_tanstack_react_query.QueryKey, unknown][];
        getQueryData: (queryKey: EdenQueryKey) => unknown;
        setInfiniteQueryData: (queryKey: EdenQueryKey, updater: _tanstack_react_query.Updater<_tanstack_react_query.InfiniteData<unknown> | undefined, _tanstack_react_query.InfiniteData<unknown> | undefined>, options?: _tanstack_react_query.SetDataOptions) => void;
        getInfiniteQueryData: (queryKey: EdenQueryKey) => _tanstack_react_query.InfiniteData<unknown> | undefined;
        setMutationDefaults: (mutationKey: EdenMutationKey, options: _tanstack_react_query.MutationOptions | ((args: {
            canonicalMutationFn: (input: unknown) => Promise<unknown>;
        }) => _tanstack_react_query.MutationOptions)) => void;
        getMutationDefaults: (mutationKey: EdenMutationKey) => _tanstack_react_query.MutationOptions | undefined;
        isMutating: (filters: {
            mutationKey: EdenMutationKey;
        }) => number;
        abortOnUnmount: boolean;
        queryClient: _tanstack_react_query.QueryClient;
        client: EdenClient<TElysia>;
        ssrContext: TSSRContext | null;
        ssrState: SSRState;
    };
    createUtils: (props: EdenContextProps<TElysia, TSSRContext>) => ProtectedIntersection<DecoratedEdenTreatyReactQueryContextProps<TElysia, TSSRContext>, EdenTreatyReactQueryUtilsProxy<TElysia["_routes"], [], _aydee_app_eden.ExtractEdenTreatyRouteParams<TElysia["_routes"]>>>;
    useContext: (context?: EdenContextState<TElysia, TSSRContext>) => ProtectedIntersection<DecoratedEdenTreatyReactQueryContextProps<TElysia, TSSRContext>, EdenTreatyReactQueryUtilsProxy<TElysia["_routes"], [], _aydee_app_eden.ExtractEdenTreatyRouteParams<TElysia["_routes"]>>>;
    useUtils: (context?: EdenContextState<TElysia, TSSRContext>) => ProtectedIntersection<DecoratedEdenTreatyReactQueryContextProps<TElysia, TSSRContext>, EdenTreatyReactQueryUtilsProxy<TElysia["_routes"], [], _aydee_app_eden.ExtractEdenTreatyRouteParams<TElysia["_routes"]>>>;
    useQuery: (originalPaths: readonly string[], input?: InferRouteOptions | SkipToken, options?: EdenUseQueryOptions<unknown, unknown, TError>) => EdenUseQueryResult<unknown, TError>;
    useSuspenseQuery: (originalPaths: readonly string[], input: InferRouteOptions, options?: EdenUseSuspenseQueryOptions<unknown, unknown, TError>) => EdenUseSuspenseQueryResult<unknown, TError>;
    useInfiniteQuery: (originalPaths: readonly string[], input?: InferRouteOptions | SkipToken, options?: EdenUseInfiniteQueryOptions<unknown, unknown, TError>) => EdenUseInfiniteQueryResult<unknown, TError, unknown>;
    useSuspenseInfiniteQuery: (originalPaths: readonly string[], input: InferRouteOptions, options?: EdenUseSuspenseInfiniteQueryOptions<unknown, unknown, TError>) => EdenUseSuspenseInfiniteQueryResult<unknown, TError, unknown>;
    useQueries: EdenTreatyUseQueries<TElysia>;
    useSuspenseQueries: EdenTreatyUseSuspenseQueries<TElysia>;
    useMutation: (originalPaths: readonly string[], input?: InferRouteOptions, options?: EdenUseMutationOptions<unknown, TError, unknown, unknown>) => EdenUseMutationResult<unknown, TError, unknown, unknown, unknown>;
    useSubscription: (path: readonly string[], input: unknown, opts: EdenUseSubscriptionOptions<unknown, TError>) => void;
};
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 EdenTreatyReactQuery<TElysia extends AnyElysia, TSSRContext> = EdenTreatyReactQueryBase<TElysia, TSSRContext> & EdenTreatyReactQueryHooks<TElysia>;
/**
 * Utilities available at the eden-treaty + react-query root.
 */
interface EdenTreatyReactQueryBase<TElysia extends AnyElysia, TSSRContext> {
    /**
     * Get utilities provided via the context API.
     *
     * @see https://trpc.io/docs/v11/client/react/useUtils
     */
    useUtils(): EdenTreatyReactQueryUtils<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>): EdenContextState<TElysia, TSSRContext>;
    /**
     * Creates a proxy that can invoke tanstack-query helper functions.
     */
    createUtils(props: EdenContextProps<TElysia, TSSRContext>): EdenTreatyReactQueryUtils<TElysia, TSSRContext>;
    /**
     * Get utilities provided via the context API.
     *
     * @deprecated renamed to {@link useUtils} and will be removed in a future tRPC version
     *
     * @link https://trpc.io/docs/v11/client/react/useUtils
     */
    useContext(): EdenTreatyReactQueryUtils<TElysia, TSSRContext>;
    /**
     * React.Provider to set the context.
     */
    Provider: EdenProvider<TElysia, TSSRContext>;
    /**
     * Wraps the `useQueries` react-query hook in a type-safe proxy.
     */
    useQueries: EdenTreatyUseQueries<TElysia>;
    /**
     * Wraps the `useSuspenseQueries` react-query hook in a type-safe proxy.
     */
    useSuspenseQueries: EdenTreatyUseSuspenseQueries<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>;
}
/**
 * A strongly-typed proxy with svelte-query hooks for interacting with the {@link AnyElysia} backend.
 */
type EdenTreatyReactQueryHooks<T extends AnyElysia> = T extends {
    _routes: infer TSchema extends Record<string, any>;
} ? EdenTreatyReactQueryHooksProxy<TSchema> : '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 EdenTreatyReactQueryHooksProxy<TSchema extends Record<string, any>, TPath extends any[] = [], TRouteParams = ExtractEdenTreatyRouteParams<TSchema>> = EdenTreatyReactQueryPathHooks<TSchema, TPath, TRouteParams> & EdenTreatyReactQueryHooksPathParameterHook<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 EdenTreatyReactQueryPathHooks<TSchema extends Record<string, any>, TPath extends any[] = [], TRouteParams = ExtractEdenTreatyRouteParams<TSchema>> = {
    [K in Exclude<keyof TSchema, keyof TRouteParams>]: TSchema[K] extends RouteSchema ? EdenTreatyReactQueryRouteLeaf<TSchema[K], K, TPath> : EdenTreatyReactQueryHooksProxy<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 EdenTreatyReactQueryHooksPathParameterHook<TSchema extends Record<string, any>, TPath extends any[] = [], TRouteParams = {}> = {} extends TRouteParams ? {} : (params: ExtractEdenTreatyRouteParamsInput<TRouteParams>) => EdenTreatyReactQueryHooksProxy<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 EdenTreatyReactQueryRouteLeaf<TRoute extends RouteSchema, TMethod, TPath extends any[] = []> = TMethod extends HttpQueryMethod ? EdenTreatyReactQueryLeaf<TRoute, TPath> : TMethod extends HttpMutationMethod ? EdenTreatyReactQueryMutationLeaf<TRoute, TPath> : TMethod extends HttpSubscriptionMethod ? EdenTreatyReactQuerySubscriptionLeaf<TRoute, TPath> : EdenTreatyReactQueryUnknownLeaf<TRoute, TPath>;
/**
 * react-query hooks for "infinite-queries".
 * e.g. routes with a "GET" endpoint that also expects "cursor" as a query parameter.
 */
type EdenTreatyReactQueryLeaf<TRoute extends RouteSchema, TPath extends any[] = [], TInput extends InferRouteOptions<TRoute> = InferRouteOptions<TRoute>> = {
    useQuery: EdenUseQuery<TRoute, TPath>;
    useSuspenseQuery: EdenUseSuspenseQuery<TRoute, TPath>;
} & (InfiniteCursorKey extends keyof (TInput['params'] & TInput['query']) ? EdenTreatyReactQueryInfiniteQueryLeaf<TRoute, TPath> : {});
/**
 * react-query hooks for "infinite-queries".
 * e.g. routes with a "GET" endpoint that also expects "cursor" as a query parameter.
 */
type EdenTreatyReactQueryInfiniteQueryLeaf<TRoute extends RouteSchema, TPath extends any[] = []> = {
    useInfiniteQuery: EdenUseInfiniteQuery<TRoute, TPath>;
    useSuspenseInfiniteQuery: EdenUseSuspenseInfiniteQuery<TRoute, TPath>;
};
/**
 * react-query hooks for "mutations". e.g. Basically routes with any HTTP methods other than "GET."
 */
type EdenTreatyReactQueryMutationLeaf<TRoute extends RouteSchema, TPath extends any[] = []> = {
    useMutation: EdenUseMutation<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 EdenTreatyReactQuerySubscriptionLeaf<TRoute extends RouteSchema, TPath extends any[] = [], TInput = InferRouteOptions<TRoute>> = {
    options: Prettify<EdenRequestOptions & TInput>;
    queryKey: EdenQueryKey<TPath>;
};
/**
 * react-query hooks for any unknown HTTP methods will just expose all known hooks for now.
 *
 * @todo Decide what hooks to expose...
 */
type EdenTreatyReactQueryUnknownLeaf<TRoute extends RouteSchema, TPath extends any[] = []> = EdenTreatyReactQueryLeaf<TRoute, TPath> & EdenTreatyReactQueryInfiniteQueryLeaf<TRoute, TPath> & EdenTreatyReactQueryMutationLeaf<TRoute, TPath> & EdenTreatyReactQuerySubscriptionLeaf<TRoute, TPath>;
declare function createEdenTreatyReactQuery<TElysia extends AnyElysia, TSSRContext = unknown>(config?: EdenQueryConfig<TElysia>): EdenTreatyReactQuery<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 }, { cursor: '456' } ]
 */
declare function createEdenTreatyReactQueryProxy<T extends AnyElysia = AnyElysia>(rootHooks: EdenTreatyQueryRootHooks<T>, config?: EdenQueryConfig<T>, paths?: (string | symbol)[], pathParams?: Record<string, any>[]): () => void;
declare function getQueryKey<TSchema extends Record<string, any>>(route: EdenTreatyReactQueryHooksProxy<TSchema>, input?: TSchema extends RouteSchema ? InferRouteOptions<TSchema> : any, type?: EdenQueryType): EdenQueryKey;
declare function getMutationKey<TSchema extends RouteSchema>(route: EdenTreatyReactQueryHooksProxy<TSchema>, options?: EdenQueryKeyOptions): EdenMutationKey;
declare const routeDefinitionSymbol: unique symbol;

export { type DecoratedEdenTreatyReactQueryContextProps, type EdenQueryUtilsMutationUtils, type EdenTreatyQueryRootHooks, type EdenTreatyQueryUtilsInfiniteUtils, type EdenTreatyQueryUtilsQueryUtils, type EdenTreatyQueryUtilsUniversalUtils, type EdenTreatyReactQuery, type EdenTreatyReactQueryBase, type EdenTreatyReactQueryContextProps, type EdenTreatyReactQueryHooks, type EdenTreatyReactQueryHooksPathParameterHook, type EdenTreatyReactQueryHooksProxy, type EdenTreatyReactQueryInfiniteQueryLeaf, type EdenTreatyReactQueryLeaf, type EdenTreatyReactQueryMutationLeaf, type EdenTreatyReactQueryPathHooks, type EdenTreatyReactQueryRouteLeaf, type EdenTreatyReactQuerySubscriptionLeaf, type EdenTreatyReactQueryUnknownLeaf, type EdenTreatyReactQueryUtils, type EdenTreatyReactQueryUtilsProxy, type EdenTreatyUseQueries, type EdenTreatyUseQueriesHook, type EdenTreatyUseQueriesProxy, type EdenTreatyUseQueriesProxyMapping, type EdenTreatyUseSuspenseQueries, type EdenTreatyUseSuspenseQueriesProxy, type EdenTreatyUseSuspenseQueriesProxyMapping, type InferTreatyQueryIO, type InferTreatyQueryIOMapping, type InferTreatyQueryInput, type InferTreatyQueryInputMapping, type InferTreatyQueryOutput, type InferTreatyQueryOutputMapping, type UseSuspenseQueriesHook, type UseSuspenseQueriesResult, createEdenTreatyQueryRootHooks, createEdenTreatyQueryUtils, createEdenTreatyQueryUtilsProxy, createEdenTreatyReactQuery, createEdenTreatyReactQueryProxy, createTreatyUseQueriesProxy, createTreatyUseSuspenseQueriesProxy, getMutationKey, getQueryKey, routeDefinitionSymbol };