import { ClientContext, Client, AnyNestedClient, InferClientContext, InferClientError } from '@orpc/client';
import { RouterContract, RouterContractClient, ContractClientFactory, AnySchema, ErrorMap, MetaPlugin, Meta, InferSchemaInput, InferSchemaOutput, ORPCErrorFromErrorMap } from '@orpc/contract';
import { JsonifiedClient } from '@orpc/openapi';
import { Promisable, PartialDeep, Interceptor, PromiseWithError, MaybeOptionalOptions, OrderablePlugin, Public, ThrowableError } from '@orpc/shared';
import { EntryKey, UseQueryOptions, UseMutationOptionsGlobal, DefineQueryOptions, UseInfiniteQueryData, DefineInfiniteQueryOptions, UseMutationOptions, DefineQueryOptionsTagged, DefineInfiniteQueryOptionsTagged, DefineMutationOptionsTagged, UseInfiniteQueryFnContext, EntryKeyTagged, _EmptyObject } from '@pinia/colada';

type InferStreamedQueryOutput<TOutput> = TOutput extends AsyncIterable<infer U> ? U[] : never;
type InferLiveQueryOutput<TOutput> = TOutput extends AsyncIterable<infer U> ? U : never;
type UseQueryFnContext = Parameters<UseQueryOptions<any>['query']>[0];
/**
 * The context passed to the mutation function, including the merged
 * `UseMutationGlobalContext` values provided by a global `onMutate` hook.
 */
type UseMutationFnContext = Parameters<NonNullable<UseMutationOptionsGlobal['onSuccess']>>[2];
declare const OPERATION_CONTEXT_SYMBOL: unique symbol;
type OperationType = 'query' | 'streamed' | 'live' | 'infinite' | 'mutation';
interface OperationContext {
    [OPERATION_CONTEXT_SYMBOL]?: {
        key: EntryKey;
        type: OperationType;
    };
}
type QueryKeyOptions<TInput> = (undefined extends TInput ? {
    input?: TInput;
} : {
    input: TInput;
}) | {
    key: EntryKey;
};
type QueryOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError, TInitialData extends TOutput | undefined> = (undefined extends TInput ? {
    input?: TInput;
} : {
    input: TInput;
}) & (object extends TClientContext ? {
    context?: TClientContext;
} : {
    context: TClientContext;
}) & Omit<DefineQueryOptions<TOutput, TError, TInitialData>, 'key' | 'query'> & Partial<Pick<DefineQueryOptions<TOutput, TError, TInitialData>, 'key' | 'query'>>;
type QueryOptionsOut<TOutput, TError, TInitialData extends TOutput | undefined> = DefineQueryOptionsTagged<TOutput, TError, TInitialData>;
type StreamedKeyOptions<TInput> = ((undefined extends TInput ? {
    input?: TInput;
} : {
    input: TInput;
}) & {
    fnOptions?: SerializableStreamedQueryOptions;
}) | {
    key: EntryKey;
};
type StreamedOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError, TInitialData extends TOutput | undefined> = QueryOptionsIn<TClientContext, TInput, TOutput, TError, TInitialData> & {
    fnOptions?: SerializableStreamedQueryOptions;
};
type StreamedOptionsOut<TOutput, TError, TInitialData extends TOutput | undefined> = QueryOptionsOut<TOutput, TError, TInitialData>;
type InfiniteKeyOptions<TInput, TPageParam> = Pick<InfiniteOptionsIn<any, TInput, any, any, TPageParam, any>, 'input' | 'initialPageParam'> | {
    key: EntryKey;
};
type InfiniteOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError, TPageParam, TInitialData extends UseInfiniteQueryData<TOutput, TPageParam> | undefined> = {
    input: (pageParam: TPageParam) => TInput;
} & (object extends TClientContext ? {
    context?: TClientContext;
} : {
    context: TClientContext;
}) & Omit<DefineInfiniteQueryOptions<TOutput, TError, TPageParam, TInitialData>, 'key' | 'query'> & Partial<Pick<DefineInfiniteQueryOptions<TOutput, TError, TPageParam, TInitialData>, 'key' | 'query'>>;
type InfiniteOptionsOut<TOutput, TError, TPageParam, TInitialData extends UseInfiniteQueryData<TOutput, TPageParam> | undefined> = DefineInfiniteQueryOptionsTagged<TOutput, TError, TPageParam, TInitialData>;
type MutationKeyOptions<TInput> = Pick<MutationOptionsIn<any, TInput, any, any, any>, 'key'>;
type MutationOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError, TMutationContext extends Record<any, any>> = (object extends TClientContext ? {
    context?: TClientContext;
} : {
    context: TClientContext;
}) & Omit<UseMutationOptions<TOutput, TInput, TError, TMutationContext>, 'mutation'> & Partial<Pick<UseMutationOptions<TOutput, TInput, TError, TMutationContext>, 'mutation'>>;
type MutationOptionsOut<TInput, TOutput, TError, TMutationContext extends Record<any, any>> = DefineMutationOptionsTagged<TOutput, TInput, TError, TMutationContext>;

interface SerializableStreamedQueryOptions {
    /**
     * Determines how data is handled when the query is fetched again
     *
     * - `'reset'`: Clears existing data and returns the query to a pending state.
     * - `'append'`: Adds new streamed chunks to the existing data.
     * - `'replace'`: Buffers streamed data and replaces the cache after the stream completes.
     *
     * @default 'reset'
     */
    refetchMode?: 'append' | 'reset' | 'replace';
    /**
     * Limits the number of data chunks stored in the query result.
     * Older chunks are removed when the limit is reached.
     *
     * @default Number.POSITIVE_INFINITY (unlimited)
     */
    maxChunks?: number;
}
/**
 * A Pinia Colada query function that accumulates streamed chunks into an array,
 * publishing each chunk to the cache entry as it arrives.
 *
 * Inspired by [TanStack Query streamedQuery](https://tanstack.com/query/latest/docs/reference/streamedQuery) where:
 * - Options are serializable
 * - The output is predictable
 */
declare function serializableStreamedQuery<T>(queryFn: (context: UseQueryFnContext) => Promisable<AsyncIterable<T>>, { refetchMode, maxChunks }?: SerializableStreamedQueryOptions): (context: UseQueryFnContext) => Promise<T[]>;

interface OperationKeyPrefixOptions {
    /**
     * Prepended as the first element of the key when present.
     * Use this to avoid key conflicts when multiple router utils share the same client.
     */
    prefix?: string;
}
type OperationKeyOptions<TType extends OperationType, TInput> = OperationKeyPrefixOptions & {
    type?: TType;
    input?: PartialDeep<TInput>;
    fnOptions?: TType extends 'streamed' ? SerializableStreamedQueryOptions : never;
};
type OperationKey<TType extends OperationType, TInput> = EntryKey & ([path: string[], options: Omit<OperationKeyOptions<TType, TInput>, 'prefix'>] | [prefix: string, path: string[], options: Omit<OperationKeyOptions<TType, TInput>, 'prefix'>]);
/**
 * Generate a Pinia Colada entry key for a procedure.
 *
 * The input is serialized to JSON-compatible values because Pinia Colada
 * requires entry keys to be serializable.
 *
 * @see {@link https://orpc.dev/docs/integrations/pinia-colada#query-mutation-key Pinia Colada Query/Mutation Key Docs}
 */
declare function generateOperationKey<TType extends OperationType, TInput>(path: string[], options?: OperationKeyOptions<TType, TInput>): OperationKey<TType, TInput>;

declare class SharedUtils<TInput> {
    protected readonly path: string[];
    protected readonly options: OperationKeyPrefixOptions;
    constructor(path: string[], options: OperationKeyPrefixOptions);
    /**
     * Generate a **partial matching** key for actions like revalidating queries, checking mutation status, etc.
     *
     * @see {@link https://orpc.dev/docs/integrations/pinia-colada#query-mutation-key Pinia Colada Query/Mutation Key Docs}
     */
    key<TType extends OperationType>(options?: Omit<OperationKeyOptions<TType, TInput>, 'prefix'>): OperationKey<TType, TInput>;
}

interface ProcedureUtilsQueryInterceptorOptions<TClientContext extends ClientContext, TInput> {
    path: string[];
    context: TClientContext & OperationContext;
    input: TInput;
    fnContext: UseQueryFnContext;
}
type ProcedureUtilsQueryInterceptor<TClientContext extends ClientContext, TInput, TOutput, TError> = Interceptor<ProcedureUtilsQueryInterceptorOptions<TClientContext, TInput>, PromiseWithError<TOutput, TError>>;
interface ProcedureUtilsStreamedInterceptorOptions<TClientContext extends ClientContext, TInput> extends ProcedureUtilsQueryInterceptorOptions<TClientContext, TInput> {
}
type ProcedureUtilsStreamedInterceptor<TClientContext extends ClientContext, TInput, TOutput, TError> = Interceptor<ProcedureUtilsStreamedInterceptorOptions<TClientContext, TInput>, PromiseWithError<InferStreamedQueryOutput<TOutput>, TError>>;
interface ProcedureUtilsLiveInterceptorOptions<TClientContext extends ClientContext, TInput> extends ProcedureUtilsQueryInterceptorOptions<TClientContext, TInput> {
}
type ProcedureUtilsLiveInterceptor<TClientContext extends ClientContext, TInput, TOutput, TError> = Interceptor<ProcedureUtilsLiveInterceptorOptions<TClientContext, TInput>, PromiseWithError<InferLiveQueryOutput<TOutput>, TError>>;
interface ProcedureUtilsInfiniteInterceptorOptions<TClientContext extends ClientContext, TInput> {
    path: string[];
    context: TClientContext & OperationContext;
    input: TInput;
    fnContext: UseInfiniteQueryFnContext<any, any, any, any>;
}
type ProcedureUtilsInfiniteInterceptor<TClientContext extends ClientContext, TInput, TOutput, TError> = Interceptor<ProcedureUtilsInfiniteInterceptorOptions<TClientContext, TInput>, PromiseWithError<TOutput, TError>>;
interface ProcedureUtilsMutationInterceptorOptions<TClientContext extends ClientContext, TInput> {
    path: string[];
    context: TClientContext & OperationContext;
    input: TInput;
    fnContext: UseMutationFnContext;
}
type ProcedureUtilsMutationInterceptor<TClientContext extends ClientContext, TInput, TOutput, TError> = Interceptor<ProcedureUtilsMutationInterceptorOptions<TClientContext, TInput>, PromiseWithError<TOutput, TError>>;
/**
 * Can be partial options for spread-merged options,
 * or a function that receives per-call options and returns overridden this.options.
 */
type ProcedureUtilsModifier<T extends object> = Partial<T> | ((options: T) => T);
interface ProcedureUtilsOptions<TClientContext extends ClientContext, TInput, TOutput, TError> extends OperationKeyPrefixOptions {
    /**
     * Key options modifier for .queryKey and .queryOptions
     * Can be partial options or a function that receives per-call options and returns override this.options.
     */
    queryKey?: ProcedureUtilsModifier<QueryKeyOptions<TInput>>;
    /**
     * Interceptors that intercept query inside .queryOptions, guaranteed to be executed.
     */
    queryInterceptors?: ProcedureUtilsQueryInterceptor<TClientContext, TInput, TOutput, TError>[];
    /**
     * Options modifier for .queryOptions
     * Can be partial options or a function that receives per-call options and returns override this.options.
     */
    queryOptions?: ProcedureUtilsModifier<QueryOptionsIn<TClientContext, TInput, TOutput, TError, TOutput | undefined>>;
    /**
     * Key options modifier for .streamedKey and .streamedOptions
     * Can be partial options or a function that receives per-call options and returns override this.options.
     */
    streamedKey?: ProcedureUtilsModifier<StreamedKeyOptions<TInput>>;
    /**
     * Interceptors that intercept query inside .streamedOptions, guaranteed to be executed.
     */
    streamedInterceptors?: ProcedureUtilsStreamedInterceptor<TClientContext, TInput, TOutput, TError>[];
    /**
     * Options modifier for .streamedOptions
     * Can be partial options or a function that receives per-call options and returns override this.options.
     */
    streamedOptions?: ProcedureUtilsModifier<StreamedOptionsIn<TClientContext, TInput, InferStreamedQueryOutput<TOutput>, TError, InferStreamedQueryOutput<TOutput> | undefined>>;
    /**
     * Key options modifier for .liveKey and .liveOptions
     * Can be partial options or a function that receives per-call options and returns override this.options.
     */
    liveKey?: ProcedureUtilsModifier<QueryKeyOptions<TInput>>;
    /**
     * Interceptors that intercept query inside .liveOptions, guaranteed to be executed.
     */
    liveInterceptors?: ProcedureUtilsLiveInterceptor<TClientContext, TInput, TOutput, TError>[];
    /**
     * Options modifier for .liveOptions
     * Can be partial options or a function that receives per-call options and returns override this.options.
     */
    liveOptions?: ProcedureUtilsModifier<QueryOptionsIn<TClientContext, TInput, InferLiveQueryOutput<TOutput>, TError, InferLiveQueryOutput<TOutput> | undefined>>;
    /**
     * Key options modifier for .infiniteKey and .infiniteOptions
     * Can be partial options or a function that receives per-call options and returns override this.options.
     */
    infiniteKey?: ProcedureUtilsModifier<InfiniteKeyOptions<TInput, unknown>>;
    /**
     * Interceptors that intercept query inside .infiniteOptions, guaranteed to be executed.
     */
    infiniteInterceptors?: ProcedureUtilsInfiniteInterceptor<TClientContext, TInput, TOutput, TError>[];
    /**
     * Options modifier for .infiniteOptions
     * Can be partial options or a function that receives per-call options and returns override this.options.
     */
    infiniteOptions?: ProcedureUtilsModifier<InfiniteOptionsIn<TClientContext, TInput, TOutput, TError, unknown, UseInfiniteQueryData<TOutput, unknown> | undefined>>;
    /**
     * Key options modifier for .mutationKey and .mutationOptions
     * Can be partial options or a function that receives per-call options and returns override this.options.
     */
    mutationKey?: ProcedureUtilsModifier<MutationKeyOptions<TInput>>;
    /**
     * Interceptors that intercept mutation inside .mutationOptions, guaranteed to be executed.
     */
    mutationInterceptors?: ProcedureUtilsMutationInterceptor<TClientContext, TInput, TOutput, TError>[];
    /**
     * Options modifier for .mutationOptions
     * Can be partial options or a function that receives per-call options and returns override this.options.
     */
    mutationOptions?: ProcedureUtilsModifier<MutationOptionsIn<TClientContext, TInput, TOutput, TError, Record<any, any>>>;
}
declare function isProcedureUtilsOptions(value: unknown): value is ProcedureUtilsOptions<any, any, any, any>;
/**
 * Merge two procedure utils options where `override` takes priority.
 * A key explicitly set to `undefined` in `override` resets the base value.
 * When both sides define a key: interceptors are concatenated (base ones run first),
 * modifiers are spread-merged when both are plain objects and composed (base applied
 * first) otherwise, with plain objects applied as regular spread merges.
 */
declare function mergeProcedureUtilsOptions<TClientContext extends ClientContext, TInput, TOutput, TError>(base: ProcedureUtilsOptions<TClientContext, TInput, TOutput, TError>, override: ProcedureUtilsOptions<TClientContext, TInput, TOutput, TError>): ProcedureUtilsOptions<TClientContext, TInput, TOutput, TError>;
declare class ProcedureUtils<TClientContext extends ClientContext, TInput, TOutput, TError> extends SharedUtils<TInput> {
    protected readonly options: ProcedureUtilsOptions<TClientContext, TInput, TOutput, TError>;
    /**
     * Calling corresponding procedure client
     *
     * @see {@link https://orpc.dev/docs/integrations/pinia-colada#calling-procedure-clients Pinia Colada Calling Procedure Client Docs}
     */
    call: Client<TClientContext, TInput, TOutput, TError>;
    constructor(path: string[], client: Client<TClientContext, TInput, TOutput, TError>, options?: ProcedureUtilsOptions<TClientContext, TInput, TOutput, TError>);
    /**
     * Generate a **full matching** key for useQuery/...
     *
     * @see {@link https://orpc.dev/docs/integrations/pinia-colada#query-mutation-key Pinia Colada Query/Mutation Key Docs}
     */
    queryKey(...rest: MaybeOptionalOptions<QueryKeyOptions<TInput>>): EntryKeyTagged<TOutput, TError>;
    /**
     * Generate options used for useQuery/...
     *
     * @see {@link https://orpc.dev/docs/integrations/pinia-colada#query-options-utility Pinia Colada Query Options Utility Docs}
     */
    queryOptions<UInitialData extends TOutput | undefined = TOutput | undefined>(...rest: MaybeOptionalOptions<QueryOptionsIn<TClientContext, TInput, TOutput, TError, UInitialData>>): NoInfer<QueryOptionsOut<TOutput, TError, UInitialData>>;
    /**
     * Generate a **full matching** key for [Streamed Query Options](https://orpc.dev/docs/integrations/pinia-colada#streamed-query-options-utility).
     *
     * @see {@link https://orpc.dev/docs/integrations/pinia-colada#query-mutation-key Pinia Colada Query/Mutation Key Docs}
     */
    streamedKey(...rest: MaybeOptionalOptions<StreamedKeyOptions<TInput>>): EntryKeyTagged<InferStreamedQueryOutput<TOutput>, TError>;
    /**
     * Configure queries for [AsyncIteratorObject](https://orpc.dev/docs/async-iterator-object).
     * The resulting data is an array of chunks, and each new chunk is appended as it arrives.
     * Works with `useQuery` and any other API that accepts query options.
     */
    streamedOptions<UInitialData extends InferStreamedQueryOutput<TOutput> | undefined = undefined>(...rest: MaybeOptionalOptions<StreamedOptionsIn<TClientContext, TInput, InferStreamedQueryOutput<TOutput>, TError, UInitialData>>): NoInfer<StreamedOptionsOut<InferStreamedQueryOutput<TOutput>, TError, UInitialData>>;
    /**
     * Generate a **full matching** key for [Live Query Options](https://orpc.dev/docs/integrations/pinia-colada#live-query-options-utility).
     *
     * @see {@link https://orpc.dev/docs/integrations/pinia-colada#query-mutation-key Pinia Colada Query/Mutation Key Docs}
     */
    liveKey(...rest: MaybeOptionalOptions<QueryKeyOptions<TInput>>): EntryKeyTagged<InferLiveQueryOutput<TOutput>, TError>;
    /**
     * Configure live queries for [AsyncIteratorObject](https://orpc.dev/docs/async-iterator-object).
     * Unlike `.streamedOptions` which accumulates chunks, live queries replace the entire result with each new chunk received.
     * Works with `useQuery` and any other API that accepts query options.
     */
    liveOptions<UInitialData extends InferLiveQueryOutput<TOutput> | undefined = undefined>(...rest: MaybeOptionalOptions<QueryOptionsIn<TClientContext, TInput, InferLiveQueryOutput<TOutput>, TError, UInitialData>>): NoInfer<QueryOptionsOut<InferLiveQueryOutput<TOutput>, TError, UInitialData>>;
    /**
     * Generate a **full matching** key for useInfiniteQuery/...
     *
     * @see {@link https://orpc.dev/docs/integrations/pinia-colada#query-mutation-key Pinia Colada Query/Mutation Key Docs}
     */
    infiniteKey<UPageParam>(optionsIn: InfiniteKeyOptions<TInput, UPageParam>): EntryKeyTagged<UseInfiniteQueryData<TOutput, UPageParam>, TError>;
    /**
     * Generate options used for useInfiniteQuery/...
     *
     * @see {@link https://orpc.dev/docs/integrations/pinia-colada#infinite-query-options-utility Pinia Colada Infinite Query Options Utility Docs}
     */
    infiniteOptions<UPageParam, UInitialData extends UseInfiniteQueryData<TOutput, UPageParam> | undefined = undefined>(optionsIn: InfiniteOptionsIn<TClientContext, TInput, TOutput, TError, UPageParam, UInitialData>): NoInfer<InfiniteOptionsOut<TOutput, TError, UPageParam, UInitialData>>;
    /**
     * Generate a **full matching** key for useMutation/...
     *
     * @see {@link https://orpc.dev/docs/integrations/pinia-colada#query-mutation-key Pinia Colada Query/Mutation Key Docs}
     */
    mutationKey(...rest: MaybeOptionalOptions<MutationKeyOptions<TInput>>): MutationOptionsOut<TInput, TOutput, TError, _EmptyObject>['key'];
    /**
     * Generate options used for useMutation/...
     *
     * @see {@link https://orpc.dev/docs/integrations/pinia-colada#mutation-options Pinia Colada Mutation Options Docs}
     */
    mutationOptions<UMutationContext extends Record<any, any> = _EmptyObject>(...rest: MaybeOptionalOptions<MutationOptionsIn<TClientContext, TInput, TOutput, TError, UMutationContext>>): NoInfer<MutationOptionsOut<TInput, TOutput, TError, UMutationContext>>;
}

interface RouterUtilsPlugin<T extends AnyNestedClient> extends OrderablePlugin {
    /**
     * Initializes the router utils plugin and returns updated router utils options.
     * Called once per plugin instance during composition.
     *
     * This method allows plugins to wrap, extend, or transform router utils options,
     * such as interceptors or configuration.
     *
     * @param options - The current router utils options from previous plugins or base configuration
     * @returns Transformed router utils options with this plugin's modifications applied
     *
     * @example
     * ```ts
     * init(options) {
     *   return {
     *     ...options,
     *     mutationInterceptors: [...(options.mutationInterceptors ?? []), myInterceptor]
     *   }
     * }
     * ```
     */
    init?(options: RouterUtilsOptions<T>): RouterUtilsOptions<T>;
    /**
     * Initializes per-procedure router utils options and returns updated options.
     * Called once per procedure utils instance during composition.
     *
     * This method allows plugins to customize merged procedure-specific defaults,
     * such as query or mutation options, for the current path.
     *
     * @param path - The current procedure path
     * @param options - The merged procedure utils options for the current procedure
     * @returns Transformed procedure utils options with this plugin's modifications applied
     */
    initProcedureOptions?(path: string[], options: ProcedureUtilsOptions<InferClientContext<T>, any, any, InferClientError<T>>): ProcedureUtilsOptions<InferClientContext<T>, any, any, InferClientError<T>>;
}
declare class CompositeRouterUtilsPlugin<T extends AnyNestedClient> implements RouterUtilsPlugin<T> {
    protected readonly plugins: RouterUtilsPlugin<T>[];
    readonly name = "~composite";
    constructor(plugins?: RouterUtilsPlugin<T>[]);
    init(options: RouterUtilsOptions<T>): RouterUtilsOptions<T>;
    initProcedureOptions(path: string[], options: ProcedureUtilsOptions<InferClientContext<T>, any, any, InferClientError<T>>): ProcedureUtilsOptions<InferClientContext<T>, any, any, InferClientError<T>>;
}

type RouterUtils<T extends AnyNestedClient> = T extends Client<infer UClientContext, infer UInput, infer UOutput, infer UError> ? Public<ProcedureUtils<UClientContext, UInput, UOutput, UError>> : {
    [K in keyof T]: T[K] extends AnyNestedClient ? RouterUtils<T[K]> : never;
} & Public<SharedUtils<unknown>>;
type RouterUtilsScoped<T extends AnyNestedClient> = T extends Client<infer UClientContext, infer UInput, infer UOutput, infer UError> ? ProcedureUtilsOptions<UClientContext, UInput, UOutput, UError> : {
    [K in keyof T]?: T[K] extends AnyNestedClient ? RouterUtilsScoped<T[K]> : never;
};
interface RouterUtilsOptions<T extends AnyNestedClient> extends OperationKeyPrefixOptions {
    /**
     * Base path for all query keys.
     *
     * @internal
     */
    path?: string[] | undefined;
    /**
     * Interceptors that intercept query inside .queryOptions
     */
    queryInterceptors?: ProcedureUtilsQueryInterceptor<InferClientContext<T>, unknown, unknown, InferClientError<T>>[];
    /**
     * Interceptors that intercept query inside .streamedOptions
     */
    streamedInterceptors?: ProcedureUtilsStreamedInterceptor<InferClientContext<T>, unknown, unknown, InferClientError<T>>[];
    /**
     * Interceptors that intercept query inside .liveOptions
     */
    liveInterceptors?: ProcedureUtilsLiveInterceptor<InferClientContext<T>, unknown, unknown, InferClientError<T>>[];
    /**
     * Interceptors that intercept query inside .infiniteOptions
     */
    infiniteInterceptors?: ProcedureUtilsInfiniteInterceptor<InferClientContext<T>, unknown, unknown, InferClientError<T>>[];
    /**
     * Interceptors that intercept mutation inside .mutationOptions
     */
    mutationInterceptors?: ProcedureUtilsMutationInterceptor<InferClientContext<T>, unknown, unknown, InferClientError<T>>[];
    /**
     * Per-procedure options following the shape of the router.
     * Allows fine-grained configuration of individual procedure utils
     * without affecting the rest of the router.
     */
    scoped?: RouterUtilsScoped<T> | undefined;
    /**
     * Plugins to extend router utils behavior.
     */
    plugins?: RouterUtilsPlugin<T>[] | undefined;
}
/**
 * Create a router utils from a client.
 *
 * @info Both client-side and server-side clients are supported.
 * @see {@link https://orpc.dev/docs/integrations/pinia-colada Pinia Colada Docs}
 */
declare function createRouterUtils<T extends AnyNestedClient>(client: T, options?: NoInfer<RouterUtilsOptions<T>>): RouterUtils<T>;

interface ContractUtilsFactory<TClientContext extends ClientContext> {
    <T extends RouterContract>(contract: T): RouterUtils<RouterContractClient<T, TClientContext>>;
}
interface ContractUtilsFactoryOptions<TClientContext extends ClientContext> extends Omit<RouterUtilsOptions<RouterContractClient<RouterContract, TClientContext>>, 'path'> {
}
declare function createContractUtilsFactory<TClientContext extends ClientContext>(clientFactory: ContractClientFactory<TClientContext>, options: ContractUtilsFactoryOptions<TClientContext>): ContractUtilsFactory<TClientContext>;
interface ContractJsonifiedUtilsFactory<TClientContext extends ClientContext> {
    <T extends RouterContract>(contract: T): RouterUtils<JsonifiedClient<RouterContractClient<T, TClientContext>>>;
}
interface ContractJsonifiedUtilsFactoryOptions<TClientContext extends ClientContext> extends Omit<RouterUtilsOptions<JsonifiedClient<RouterContractClient<RouterContract, TClientContext>>>, 'path'> {
}
declare function createContractJsonifiedUtilsFactory<TClientContext extends ClientContext>(clientFactory: ContractClientFactory<TClientContext>, options: ContractJsonifiedUtilsFactoryOptions<TClientContext>): ContractJsonifiedUtilsFactory<TClientContext>;

/**
 * A Pinia Colada query function that publishes each streamed chunk to the
 * cache entry as it arrives, replacing the previous value.
 */
declare function liveQuery<T>(queryFn: (context: UseQueryFnContext) => Promisable<AsyncIterable<T>>): (context: UseQueryFnContext) => Promise<T>;

type PiniaColadaMetaOptions<TClientContext extends ClientContext, TInput, TOutput, TError> = Omit<ProcedureUtilsOptions<TClientContext, TInput, TOutput, TError>, 'prefix'>;
interface PiniaColadaMetaPlugin<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> extends MetaPlugin<TInputSchema, TOutputSchema, TErrorMap> {
    name: '~pinia-colada';
}
/**
 * Define base Pinia Colada options and interceptors on a procedure contract.
 * Applied multiple times, later options are spread-merged with higher priority
 * while interceptors are concatenated. A key explicitly set to `undefined`
 * resets the value from earlier applications instead of merging.
 *
 * Apply them to router utils with {@link ContractOptionsUtilsPlugin}.
 *
 * @see {@link https://orpc.dev/docs/integrations/pinia-colada#contract-options-plugin Pinia Colada Contract Options Plugin Docs}
 */
declare function piniaColada<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap>(options: PiniaColadaMetaOptions<ClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | ThrowableError>): PiniaColadaMetaPlugin<TInputSchema, TOutputSchema, TErrorMap>;
declare function getPiniaColadaMeta(procedureOrLazy: {
    '~orpc': {
        meta: Meta;
    };
}): PiniaColadaMetaOptions<ClientContext, unknown, unknown, ThrowableError> | undefined;
/**
 * Router utils plugin that applies base options defined via {@link piniaColada}
 * on the given router contract. Meta options act as the base layer: options defined
 * on the utils override them, and utils interceptors run after meta interceptors.
 *
 * The contract shape must match the client the utils are created from,
 * so pass the root router contract when utils paths start from the root.
 *
 * @see {@link https://orpc.dev/docs/integrations/pinia-colada#contract-options-plugin Pinia Colada Contract Options Plugin Docs}
 */
declare class ContractOptionsUtilsPlugin<T extends AnyNestedClient = AnyNestedClient> implements RouterUtilsPlugin<T> {
    private readonly contract;
    readonly name = "~contract-options";
    constructor(contract: RouterContract);
    initProcedureOptions(path: string[], options: ProcedureUtilsOptions<InferClientContext<T>, any, any, InferClientError<T>>): ProcedureUtilsOptions<InferClientContext<T>, any, any, InferClientError<T>>;
}

export { CompositeRouterUtilsPlugin, ContractOptionsUtilsPlugin, OPERATION_CONTEXT_SYMBOL, OPERATION_CONTEXT_SYMBOL as PINIA_COLADA_OPERATION_CONTEXT_SYMBOL, ProcedureUtils, SharedUtils, createContractJsonifiedUtilsFactory, createContractUtilsFactory, createRouterUtils as createPiniaColadaUtils, createRouterUtils, generateOperationKey, getPiniaColadaMeta, isProcedureUtilsOptions, liveQuery, mergeProcedureUtilsOptions, piniaColada, serializableStreamedQuery };
export type { ContractJsonifiedUtilsFactory, ContractJsonifiedUtilsFactoryOptions, ContractUtilsFactory, ContractUtilsFactoryOptions, InferLiveQueryOutput, InferStreamedQueryOutput, InfiniteKeyOptions, InfiniteOptionsIn, InfiniteOptionsOut, MutationKeyOptions, MutationOptionsIn, MutationOptionsOut, OperationContext, OperationKey, OperationKeyOptions, OperationKeyPrefixOptions, OperationType, PiniaColadaMetaOptions, PiniaColadaMetaPlugin, OperationContext as PiniaColadaOperationContext, ProcedureUtilsInfiniteInterceptor, ProcedureUtilsInfiniteInterceptorOptions, ProcedureUtilsLiveInterceptor, ProcedureUtilsLiveInterceptorOptions, ProcedureUtilsModifier, ProcedureUtilsMutationInterceptor, ProcedureUtilsMutationInterceptorOptions, ProcedureUtilsOptions, ProcedureUtilsQueryInterceptor, ProcedureUtilsQueryInterceptorOptions, ProcedureUtilsStreamedInterceptor, ProcedureUtilsStreamedInterceptorOptions, QueryKeyOptions, QueryOptionsIn, QueryOptionsOut, RouterUtils, RouterUtilsOptions, RouterUtilsPlugin, RouterUtilsScoped, SerializableStreamedQueryOptions, StreamedKeyOptions, StreamedOptionsIn, StreamedOptionsOut, UseMutationFnContext, UseQueryFnContext };