import { type DefaultError, type InfiniteData, type QueryKey, type UseInfiniteQueryOptions, type UseInfiniteQueryReturnType, type UseMutationOptions, type UseMutationReturnType, type UseQueryOptions, type UseQueryReturnType } from '@tanstack/vue-query';
import { type InferExtQueryArgs, type InferExtResult, type InferOptions, type InferSchema } from '@zenstackhq/client-helpers';
import type { AggregateArgs, AggregateResult, BatchResult, ClientContract, CountArgs, CountResult, CreateArgs, CreateManyAndReturnArgs, CreateManyArgs, DeleteArgs, DeleteManyArgs, ExistsArgs, ExtQueryArgsBase, ExtResultBase, FindFirstArgs, FindManyArgs, FindUniqueArgs, GetProcedure, GetProcedureNames, GetSlicedModels, GetSlicedProcedures, GroupByArgs, GroupByResult, ProcedureEnvelope, QueryOptions, SelectSubset, SimplifiedPlainResult, SimplifiedResult, Subset, UpdateArgs, UpdateManyAndReturnArgs, UpdateManyArgs, UpsertArgs } from '@zenstackhq/orm';
import type { GetModels, SchemaDef } from '@zenstackhq/schema';
import { type MaybeRefOrGetter, type Ref, type UnwrapRef } from 'vue';
import type { ExtraMutationOptions, ExtraQueryOptions, ProcedureReturn, QueryContext, TransactionOperation, TransactionResults, TrimSlicedOperations, WithOptimistic } from './common/types.js';
export { AnyNull, DbNull, JsonNull } from '@zenstackhq/client-helpers';
export type { InferExtQueryArgs, InferExtResult, InferOptions, InferSchema } from '@zenstackhq/client-helpers';
export type { FetchFn } from '@zenstackhq/client-helpers/fetch';
export type { SchemaDef } from '@zenstackhq/schema';
export { getQueryKey } from './common/query-key.js';
export declare const VueQueryContextKey = "zenstack-vue-query-context";
type ProcedureHookFn<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>, Options, Result, Input = ProcedureEnvelope<Schema, ProcName>> = {
    args: undefined;
} extends Input ? (args?: MaybeRefOrGetter<Input>, options?: MaybeRefOrGetter<Options>) => Result : (args: MaybeRefOrGetter<Input>, options?: MaybeRefOrGetter<Options>) => Result;
/**
 * Provide context for query settings.
 *
 * @deprecated Use {@link provideQuerySettingsContext} instead.
 */
export declare function provideHooksContext(context: QueryContext): void;
/**
 * Provide context for query settings.
 */
export declare function provideQuerySettingsContext(context: QueryContext): void;
export type ModelQueryOptions<T> = MaybeRefOrGetter<Omit<UnwrapRef<UseQueryOptions<T, DefaultError>>, 'queryKey'> & ExtraQueryOptions>;
export type ModelQueryResult<T> = UseQueryReturnType<WithOptimistic<T>, DefaultError> & {
    queryKey: Ref<QueryKey>;
};
export type ModelInfiniteQueryOptions<T, TPageParam = unknown> = MaybeRefOrGetter<Omit<UnwrapRef<UseInfiniteQueryOptions<T, DefaultError, InfiniteData<T, TPageParam>, QueryKey, TPageParam>>, 'queryKey' | 'initialPageParam'> & QueryContext>;
export type ModelInfiniteQueryResult<T> = UseInfiniteQueryReturnType<T, DefaultError> & {
    queryKey: Ref<QueryKey>;
};
export type ModelMutationOptions<T, TArgs> = MaybeRefOrGetter<Omit<UnwrapRef<UseMutationOptions<T, DefaultError, TArgs>>, 'mutationFn'> & ExtraMutationOptions>;
export type ModelMutationResult<T, TArgs> = UseMutationReturnType<T, DefaultError, TArgs, unknown>;
export type ModelMutationModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, TArgs, Array extends boolean = false, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtResult extends ExtResultBase<Schema> = {}> = Omit<ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, Options, false, Array, ExtResult>, TArgs>, 'mutateAsync'> & {
    mutateAsync<T extends TArgs>(args: T, options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>, T>): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>>;
};
/**
 * Options accepted by `$transaction.useSequential()`.
 */
export type TransactionMutationOptions<Schema extends SchemaDef, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = MaybeRefOrGetter<Omit<UnwrapRef<UseMutationOptions<unknown[], DefaultError, TransactionOperation<Schema, Options, ExtQueryArgs, ExtResult>[]>>, 'mutationFn'> & Omit<ExtraMutationOptions, 'optimisticUpdate' | 'optimisticDataProvider'>>;
/**
 * The return type of `$transaction.useSequential()`. Overrides `mutateAsync` so the
 * resolved value is a tuple of per-operation results, narrowed to each operation's
 * model + op + args (mirrors the typing of the corresponding ORM CRUD method).
 */
export type TransactionMutationResult<Schema extends SchemaDef, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = Omit<UseMutationReturnType<unknown[], DefaultError, TransactionOperation<Schema, Options, ExtQueryArgs, ExtResult>[], unknown>, 'mutateAsync'> & {
    mutateAsync<const T extends readonly TransactionOperation<Schema, Options, ExtQueryArgs, ExtResult>[]>(operations: T, options?: Omit<UseMutationOptions<TransactionResults<Schema, T, Options, ExtResult>, DefaultError, T>, 'mutationFn'>): Promise<TransactionResults<Schema, T, Options, ExtResult>>;
};
/**
 * The full set of TanStack Query hooks returned by {@link useClientQueries}.
 */
export type ClientHooks<Schema extends SchemaDef, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = {
    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options, ExtQueryArgs, ExtResult>;
} & ProcedureHooks<Schema, Options> & {
    $transaction: {
        useSequential(options?: TransactionMutationOptions<Schema, Options, ExtQueryArgs, ExtResult>): TransactionMutationResult<Schema, Options, ExtQueryArgs, ExtResult>;
    };
};
type ProcedureHookGroup<Schema extends SchemaDef, Options extends QueryOptions<Schema>> = {
    [Name in GetSlicedProcedures<Schema, Options>]: GetProcedure<Schema, Name> extends {
        mutation: true;
    } ? {
        useMutation(options?: MaybeRefOrGetter<Omit<UnwrapRef<UseMutationOptions<ProcedureReturn<Schema, Name>, DefaultError, ProcedureEnvelope<Schema, Name>>>, 'mutationFn'> & QueryContext>): UseMutationReturnType<ProcedureReturn<Schema, Name>, DefaultError, ProcedureEnvelope<Schema, Name>, unknown>;
    } : {
        useQuery: ProcedureHookFn<Schema, Name, Omit<ModelQueryOptions<ProcedureReturn<Schema, Name>>, 'optimisticUpdate'>, UseQueryReturnType<ProcedureReturn<Schema, Name>, DefaultError> & {
            queryKey: Ref<QueryKey>;
        }>;
    };
};
export type ProcedureHooks<Schema extends SchemaDef, Options extends QueryOptions<Schema>> = Schema['procedures'] extends Record<string, any> ? {
    /**
     * Custom procedures.
     */
    $procs: ProcedureHookGroup<Schema, Options>;
} : Record<never, never>;
export type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = TrimSlicedOperations<Schema, Model, Options, {
    useFindUnique<T extends FindUniqueArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args: MaybeRefOrGetter<SelectSubset<T, FindUniqueArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>>, options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>>): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
    useFindFirst<T extends FindFirstArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args?: MaybeRefOrGetter<SelectSubset<T, FindFirstArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>>, options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>>): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
    useExists<T extends ExistsArgs<Schema, Model, Options, ExtQueryArgs>>(args?: MaybeRefOrGetter<Subset<T, ExistsArgs<Schema, Model, Options, ExtQueryArgs>>>, options?: MaybeRefOrGetter<ModelQueryOptions<boolean>>): ModelQueryResult<boolean>;
    useFindMany<T extends FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args?: MaybeRefOrGetter<SelectSubset<T, FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>>, options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
    useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>, TPageParam = unknown>(args?: MaybeRefOrGetter<SelectSubset<T, FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>>, options?: MaybeRefOrGetter<ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], TPageParam>>): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], TPageParam>>;
    useCreate<T extends CreateArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
    useCreateMany<T extends CreateManyArgs<Schema, Model, Options, ExtQueryArgs>>(options?: MaybeRefOrGetter<ModelMutationOptions<BatchResult, T>>): ModelMutationResult<BatchResult, T>;
    useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>>): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
    useUpdate<T extends UpdateArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
    useUpdateMany<T extends UpdateManyArgs<Schema, Model, Options, ExtQueryArgs>>(options?: MaybeRefOrGetter<ModelMutationOptions<BatchResult, T>>): ModelMutationResult<BatchResult, T>;
    useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>>): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
    useUpsert<T extends UpsertArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
    useDelete<T extends DeleteArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
    useDeleteMany<T extends DeleteManyArgs<Schema, Model, Options, ExtQueryArgs>>(options?: MaybeRefOrGetter<ModelMutationOptions<BatchResult, T>>): ModelMutationResult<BatchResult, T>;
    useCount<T extends CountArgs<Schema, Model, Options, ExtQueryArgs>>(args?: MaybeRefOrGetter<Subset<T, CountArgs<Schema, Model, Options, ExtQueryArgs>>>, options?: MaybeRefOrGetter<ModelQueryOptions<CountResult<Schema, Model, T>>>): ModelQueryResult<CountResult<Schema, Model, T>>;
    useAggregate<T extends AggregateArgs<Schema, Model, Options, ExtQueryArgs>>(args: MaybeRefOrGetter<Subset<T, AggregateArgs<Schema, Model, Options, ExtQueryArgs>>>, options?: MaybeRefOrGetter<ModelQueryOptions<AggregateResult<Schema, Model, T>>>): ModelQueryResult<AggregateResult<Schema, Model, T>>;
    useGroupBy<T extends GroupByArgs<Schema, Model, Options, ExtQueryArgs>>(args: MaybeRefOrGetter<Subset<T, GroupByArgs<Schema, Model, Options, ExtQueryArgs>>>, options?: MaybeRefOrGetter<ModelQueryOptions<GroupByResult<Schema, Model, T>>>): ModelQueryResult<GroupByResult<Schema, Model, T>>;
}>;
/**
 * Gets data query hooks for all models in the schema.
 *
 * Accepts either a raw `SchemaDef` or a `ClientContract` type (e.g. `typeof db`) as the generic parameter.
 * When a `ClientContract` type is provided, computed fields from plugins are reflected in the result types.
 *
 * @example
 * ```typescript
 * // Basic usage with schema
 * const client = useClientQueries(schema)
 *
 * // With server client type for computed field support
 * import type { DbType } from '~/server/db'
 * const client = useClientQueries<DbType>(schema)
 * ```
 */
export declare function useClientQueries<SchemaOrClient extends SchemaDef | ClientContract<any, any, any, any, any>>(schema: InferSchema<SchemaOrClient>, options?: MaybeRefOrGetter<QueryContext>): ClientHooks<InferSchema<SchemaOrClient>, InferOptions<SchemaOrClient, InferSchema<SchemaOrClient>>, InferExtQueryArgs<SchemaOrClient> extends ExtQueryArgsBase ? InferExtQueryArgs<SchemaOrClient> : {}, InferExtResult<SchemaOrClient> extends ExtResultBase<InferSchema<SchemaOrClient>> ? InferExtResult<SchemaOrClient> : {}>;
/**
 * Gets data query hooks for a specific model in the schema.
 */
export declare function useModelQueries<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}>(schema: Schema, model: Model, rootOptions?: MaybeRefOrGetter<QueryContext>): ModelQueryHooks<Schema, Model, Options, ExtQueryArgs, ExtResult>;
export declare function useInternalQuery<TQueryFnData, TData>(_schema: SchemaDef, model: string, operation: string, args?: MaybeRefOrGetter<unknown>, options?: MaybeRefOrGetter<Omit<UnwrapRef<UseQueryOptions<TQueryFnData, DefaultError, TData>>, 'queryKey'> & ExtraQueryOptions>): {
    data: Ref<TData, TData>;
    error: Ref<Error, Error>;
    isError: Ref<true, true>;
    isPending: Ref<false, false>;
    isLoading: Ref<false, false>;
    isLoadingError: Ref<false, false>;
    isRefetchError: Ref<true, true>;
    isSuccess: Ref<false, false>;
    isPlaceholderData: Ref<false, false>;
    status: Ref<"error", "error">;
    dataUpdatedAt: Ref<number, number>;
    errorUpdatedAt: Ref<number, number>;
    failureCount: Ref<number, number>;
    failureReason: Ref<Error | null, Error | null>;
    errorUpdateCount: Ref<number, number>;
    isFetched: Ref<boolean, boolean>;
    isFetchedAfterMount: Ref<boolean, boolean>;
    isFetching: Ref<boolean, boolean>;
    isInitialLoading: Ref<boolean, boolean>;
    isPaused: Ref<boolean, boolean>;
    isRefetching: Ref<boolean, boolean>;
    isStale: Ref<boolean, boolean>;
    isEnabled: Ref<boolean, boolean>;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TData, Error>>;
    fetchStatus: Ref<import("@tanstack/query-core").FetchStatus, import("@tanstack/query-core").FetchStatus>;
    promise: Ref<Promise<TData>, Promise<TData>>;
    suspense: () => Promise<import("@tanstack/query-core").DefinedQueryObserverResult<TData, Error>>;
    queryKey: import("vue").ComputedRef<import("./common/query-key.js").QueryKey>;
} | {
    data: Ref<TData, TData>;
    error: Ref<null, null>;
    isError: Ref<false, false>;
    isPending: Ref<false, false>;
    isLoading: Ref<false, false>;
    isLoadingError: Ref<false, false>;
    isRefetchError: Ref<false, false>;
    isSuccess: Ref<true, true>;
    isPlaceholderData: Ref<false, false>;
    status: Ref<"success", "success">;
    dataUpdatedAt: Ref<number, number>;
    errorUpdatedAt: Ref<number, number>;
    failureCount: Ref<number, number>;
    failureReason: Ref<Error | null, Error | null>;
    errorUpdateCount: Ref<number, number>;
    isFetched: Ref<boolean, boolean>;
    isFetchedAfterMount: Ref<boolean, boolean>;
    isFetching: Ref<boolean, boolean>;
    isInitialLoading: Ref<boolean, boolean>;
    isPaused: Ref<boolean, boolean>;
    isRefetching: Ref<boolean, boolean>;
    isStale: Ref<boolean, boolean>;
    isEnabled: Ref<boolean, boolean>;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TData, Error>>;
    fetchStatus: Ref<import("@tanstack/query-core").FetchStatus, import("@tanstack/query-core").FetchStatus>;
    promise: Ref<Promise<TData>, Promise<TData>>;
    suspense: () => Promise<import("@tanstack/query-core").DefinedQueryObserverResult<TData, Error>>;
    queryKey: import("vue").ComputedRef<import("./common/query-key.js").QueryKey>;
};
export declare function useInternalInfiniteQuery<TQueryFnData, TData, TPageParam = unknown>(_schema: SchemaDef, model: string, operation: string, args: MaybeRefOrGetter<unknown>, options: MaybeRefOrGetter<(Omit<UnwrapRef<UseInfiniteQueryOptions<TQueryFnData, DefaultError, InfiniteData<TData, TPageParam>, QueryKey, TPageParam>>, 'queryKey' | 'initialPageParam'> & QueryContext) | undefined>): {
    data: Ref<InfiniteData<unknown, unknown>, InfiniteData<unknown, unknown>>;
    error: Ref<Error, Error>;
    isError: Ref<true, true>;
    isPending: Ref<false, false>;
    isLoading: Ref<false, false>;
    isLoadingError: Ref<false, false>;
    isRefetchError: Ref<true, true>;
    isSuccess: Ref<false, false>;
    isPlaceholderData: Ref<false, false>;
    status: Ref<"error", "error">;
    fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    hasNextPage: Ref<boolean, boolean>;
    hasPreviousPage: Ref<boolean, boolean>;
    isFetchNextPageError: Ref<boolean, boolean>;
    isFetchingNextPage: Ref<boolean, boolean>;
    isFetchPreviousPageError: Ref<boolean, boolean>;
    isFetchingPreviousPage: Ref<boolean, boolean>;
    dataUpdatedAt: Ref<number, number>;
    errorUpdatedAt: Ref<number, number>;
    failureCount: Ref<number, number>;
    failureReason: Ref<Error | null, Error | null>;
    errorUpdateCount: Ref<number, number>;
    isFetched: Ref<boolean, boolean>;
    isFetchedAfterMount: Ref<boolean, boolean>;
    isFetching: Ref<boolean, boolean>;
    isInitialLoading: Ref<boolean, boolean>;
    isPaused: Ref<boolean, boolean>;
    isRefetching: Ref<boolean, boolean>;
    isStale: Ref<boolean, boolean>;
    isEnabled: Ref<boolean, boolean>;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    fetchStatus: Ref<import("@tanstack/query-core").FetchStatus, import("@tanstack/query-core").FetchStatus>;
    promise: Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
    suspense: () => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    queryKey: import("vue").ComputedRef<import("./common/query-key.js").QueryKey>;
} | {
    data: Ref<InfiniteData<unknown, unknown>, InfiniteData<unknown, unknown>>;
    error: Ref<null, null>;
    isError: Ref<false, false>;
    isPending: Ref<false, false>;
    isLoading: Ref<false, false>;
    isLoadingError: Ref<false, false>;
    isRefetchError: Ref<false, false>;
    isFetchNextPageError: Ref<false, false>;
    isFetchPreviousPageError: Ref<false, false>;
    isSuccess: Ref<true, true>;
    isPlaceholderData: Ref<false, false>;
    status: Ref<"success", "success">;
    fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    hasNextPage: Ref<boolean, boolean>;
    hasPreviousPage: Ref<boolean, boolean>;
    isFetchingNextPage: Ref<boolean, boolean>;
    isFetchingPreviousPage: Ref<boolean, boolean>;
    dataUpdatedAt: Ref<number, number>;
    errorUpdatedAt: Ref<number, number>;
    failureCount: Ref<number, number>;
    failureReason: Ref<Error | null, Error | null>;
    errorUpdateCount: Ref<number, number>;
    isFetched: Ref<boolean, boolean>;
    isFetchedAfterMount: Ref<boolean, boolean>;
    isFetching: Ref<boolean, boolean>;
    isInitialLoading: Ref<boolean, boolean>;
    isPaused: Ref<boolean, boolean>;
    isRefetching: Ref<boolean, boolean>;
    isStale: Ref<boolean, boolean>;
    isEnabled: Ref<boolean, boolean>;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    fetchStatus: Ref<import("@tanstack/query-core").FetchStatus, import("@tanstack/query-core").FetchStatus>;
    promise: Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
    suspense: () => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    queryKey: import("vue").ComputedRef<import("./common/query-key.js").QueryKey>;
} | {
    data: Ref<undefined, undefined>;
    error: Ref<Error, Error>;
    isError: Ref<true, true>;
    isPending: Ref<false, false>;
    isLoading: Ref<false, false>;
    isLoadingError: Ref<true, true>;
    isRefetchError: Ref<false, false>;
    isFetchNextPageError: Ref<false, false>;
    isFetchPreviousPageError: Ref<false, false>;
    isSuccess: Ref<false, false>;
    isPlaceholderData: Ref<false, false>;
    status: Ref<"error", "error">;
    fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    hasNextPage: Ref<boolean, boolean>;
    hasPreviousPage: Ref<boolean, boolean>;
    isFetchingNextPage: Ref<boolean, boolean>;
    isFetchingPreviousPage: Ref<boolean, boolean>;
    dataUpdatedAt: Ref<number, number>;
    errorUpdatedAt: Ref<number, number>;
    failureCount: Ref<number, number>;
    failureReason: Ref<Error | null, Error | null>;
    errorUpdateCount: Ref<number, number>;
    isFetched: Ref<boolean, boolean>;
    isFetchedAfterMount: Ref<boolean, boolean>;
    isFetching: Ref<boolean, boolean>;
    isInitialLoading: Ref<boolean, boolean>;
    isPaused: Ref<boolean, boolean>;
    isRefetching: Ref<boolean, boolean>;
    isStale: Ref<boolean, boolean>;
    isEnabled: Ref<boolean, boolean>;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    fetchStatus: Ref<import("@tanstack/query-core").FetchStatus, import("@tanstack/query-core").FetchStatus>;
    promise: Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
    suspense: () => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    queryKey: import("vue").ComputedRef<import("./common/query-key.js").QueryKey>;
} | {
    data: Ref<undefined, undefined>;
    error: Ref<null, null>;
    isError: Ref<false, false>;
    isPending: Ref<true, true>;
    isLoading: Ref<true, true>;
    isLoadingError: Ref<false, false>;
    isRefetchError: Ref<false, false>;
    isFetchNextPageError: Ref<false, false>;
    isFetchPreviousPageError: Ref<false, false>;
    isSuccess: Ref<false, false>;
    isPlaceholderData: Ref<false, false>;
    status: Ref<"pending", "pending">;
    fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    hasNextPage: Ref<boolean, boolean>;
    hasPreviousPage: Ref<boolean, boolean>;
    isFetchingNextPage: Ref<boolean, boolean>;
    isFetchingPreviousPage: Ref<boolean, boolean>;
    dataUpdatedAt: Ref<number, number>;
    errorUpdatedAt: Ref<number, number>;
    failureCount: Ref<number, number>;
    failureReason: Ref<Error | null, Error | null>;
    errorUpdateCount: Ref<number, number>;
    isFetched: Ref<boolean, boolean>;
    isFetchedAfterMount: Ref<boolean, boolean>;
    isFetching: Ref<boolean, boolean>;
    isInitialLoading: Ref<boolean, boolean>;
    isPaused: Ref<boolean, boolean>;
    isRefetching: Ref<boolean, boolean>;
    isStale: Ref<boolean, boolean>;
    isEnabled: Ref<boolean, boolean>;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    fetchStatus: Ref<import("@tanstack/query-core").FetchStatus, import("@tanstack/query-core").FetchStatus>;
    promise: Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
    suspense: () => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    queryKey: import("vue").ComputedRef<import("./common/query-key.js").QueryKey>;
} | {
    data: Ref<undefined, undefined>;
    error: Ref<null, null>;
    isError: Ref<false, false>;
    isPending: Ref<true, true>;
    isLoadingError: Ref<false, false>;
    isRefetchError: Ref<false, false>;
    isFetchNextPageError: Ref<false, false>;
    isFetchPreviousPageError: Ref<false, false>;
    isSuccess: Ref<false, false>;
    isPlaceholderData: Ref<false, false>;
    status: Ref<"pending", "pending">;
    fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    hasNextPage: Ref<boolean, boolean>;
    hasPreviousPage: Ref<boolean, boolean>;
    isFetchingNextPage: Ref<boolean, boolean>;
    isFetchingPreviousPage: Ref<boolean, boolean>;
    dataUpdatedAt: Ref<number, number>;
    errorUpdatedAt: Ref<number, number>;
    failureCount: Ref<number, number>;
    failureReason: Ref<Error | null, Error | null>;
    errorUpdateCount: Ref<number, number>;
    isFetched: Ref<boolean, boolean>;
    isFetchedAfterMount: Ref<boolean, boolean>;
    isFetching: Ref<boolean, boolean>;
    isLoading: Ref<boolean, boolean>;
    isInitialLoading: Ref<boolean, boolean>;
    isPaused: Ref<boolean, boolean>;
    isRefetching: Ref<boolean, boolean>;
    isStale: Ref<boolean, boolean>;
    isEnabled: Ref<boolean, boolean>;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    fetchStatus: Ref<import("@tanstack/query-core").FetchStatus, import("@tanstack/query-core").FetchStatus>;
    promise: Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
    suspense: () => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    queryKey: import("vue").ComputedRef<import("./common/query-key.js").QueryKey>;
} | {
    data: Ref<InfiniteData<unknown, unknown>, InfiniteData<unknown, unknown>>;
    isError: Ref<false, false>;
    error: Ref<null, null>;
    isPending: Ref<false, false>;
    isLoading: Ref<false, false>;
    isLoadingError: Ref<false, false>;
    isRefetchError: Ref<false, false>;
    isSuccess: Ref<true, true>;
    isPlaceholderData: Ref<true, true>;
    isFetchNextPageError: Ref<false, false>;
    isFetchPreviousPageError: Ref<false, false>;
    status: Ref<"success", "success">;
    fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    hasNextPage: Ref<boolean, boolean>;
    hasPreviousPage: Ref<boolean, boolean>;
    isFetchingNextPage: Ref<boolean, boolean>;
    isFetchingPreviousPage: Ref<boolean, boolean>;
    dataUpdatedAt: Ref<number, number>;
    errorUpdatedAt: Ref<number, number>;
    failureCount: Ref<number, number>;
    failureReason: Ref<Error | null, Error | null>;
    errorUpdateCount: Ref<number, number>;
    isFetched: Ref<boolean, boolean>;
    isFetchedAfterMount: Ref<boolean, boolean>;
    isFetching: Ref<boolean, boolean>;
    isInitialLoading: Ref<boolean, boolean>;
    isPaused: Ref<boolean, boolean>;
    isRefetching: Ref<boolean, boolean>;
    isStale: Ref<boolean, boolean>;
    isEnabled: Ref<boolean, boolean>;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    fetchStatus: Ref<import("@tanstack/query-core").FetchStatus, import("@tanstack/query-core").FetchStatus>;
    promise: Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
    suspense: () => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
    queryKey: import("vue").ComputedRef<import("./common/query-key.js").QueryKey>;
};
/**
 * Creates a vue-query mutation
 *
 * @private
 *
 * @param model The name of the model under mutation.
 * @param method The HTTP method.
 * @param operation The mutation operation (e.g. `create`).
 * @param options The vue-query options.
 * @param checkReadBack Whether to check for read back errors and return undefined if found.
 */
export declare function useInternalMutation<TArgs, R = any>(schema: SchemaDef, model: string, method: 'POST' | 'PUT' | 'DELETE', operation: string, options?: MaybeRefOrGetter<Omit<UnwrapRef<UseMutationOptions<R, DefaultError, TArgs>>, 'mutationFn'> & ExtraMutationOptions>): UseMutationReturnType<R, Error, TArgs, unknown, Omit<import("@tanstack/query-core").MutationObserverIdleResult<R, Error, TArgs, unknown>, "mutate" | "reset"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<R, Error, TArgs, unknown>, "mutate" | "reset"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<R, Error, TArgs, unknown>, "mutate" | "reset"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<R, Error, TArgs, unknown>, "mutate" | "reset">>;
export declare function useInternalTransactionMutation<Schema extends SchemaDef, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}>(schema: Schema, options?: TransactionMutationOptions<Schema, Options, ExtQueryArgs, ExtResult>): TransactionMutationResult<Schema, Options, ExtQueryArgs, ExtResult>;