import { type DefaultError, type InfiniteData, type QueryKey, type UseInfiniteQueryOptions, type UseInfiniteQueryResult, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult, type UseSuspenseInfiniteQueryOptions, type UseSuspenseInfiniteQueryResult, type UseSuspenseQueryOptions, type UseSuspenseQueryResult } from '@tanstack/react-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 { ExtraMutationOptions, ExtraQueryOptions, ProcedureReturn, QueryContext, TransactionOperation, TransactionResults, TrimSlicedOperations, WithOptimistic } from './common/types.js';
export { AnyNull, DbNull, JsonNull } from '@zenstackhq/client-helpers';
export type { 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';
type ProcedureHookFn<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>, Options, Result, Input = ProcedureEnvelope<Schema, ProcName>> = {
    args: undefined;
} extends Input ? (input?: Input, options?: Options) => Result : (input: Input, options?: Options) => Result;
/**
 * React context for query settings.
 */
export declare const QuerySettingsContext: import("react").Context<QueryContext>;
/**
 * React context provider for configuring query settings.
 */
export declare const QuerySettingsProvider: import("react").Provider<QueryContext>;
/**
 * React context provider for configuring query settings.
 *
 * @deprecated Use {@link QuerySettingsProvider} instead.
 */
export declare const Provider: import("react").Provider<QueryContext>;
export type ModelQueryOptions<T> = Omit<UseQueryOptions<T, DefaultError>, 'queryKey'> & ExtraQueryOptions;
export type ModelQueryResult<T> = UseQueryResult<WithOptimistic<T>, DefaultError> & {
    queryKey: QueryKey;
};
export type ModelSuspenseQueryOptions<T> = Omit<UseSuspenseQueryOptions<T, DefaultError>, 'queryKey'> & ExtraQueryOptions;
export type ModelSuspenseQueryResult<T> = UseSuspenseQueryResult<WithOptimistic<T>, DefaultError> & {
    queryKey: QueryKey;
};
export type ModelInfiniteQueryOptions<T, TPageParam = unknown> = Omit<UseInfiniteQueryOptions<T, DefaultError, InfiniteData<T, TPageParam>, QueryKey, TPageParam>, 'queryKey' | 'initialPageParam'>;
export type ModelInfiniteQueryResult<T> = UseInfiniteQueryResult<T, DefaultError> & {
    queryKey: QueryKey;
};
export type ModelSuspenseInfiniteQueryOptions<T, TPageParam = unknown> = Omit<UseSuspenseInfiniteQueryOptions<T, DefaultError, InfiniteData<T, TPageParam>, QueryKey, TPageParam>, 'queryKey' | 'initialPageParam'>;
export type ModelSuspenseInfiniteQueryResult<T> = UseSuspenseInfiniteQueryResult<T, DefaultError> & {
    queryKey: QueryKey;
};
export type ModelMutationOptions<T, TArgs> = Omit<UseMutationOptions<T, DefaultError, TArgs>, 'mutationFn'> & ExtraMutationOptions;
export type ModelMutationResult<T, TArgs> = UseMutationResult<T, DefaultError, TArgs>;
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> = {}> = Omit<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<UseMutationResult<unknown[], DefaultError, TransactionOperation<Schema, Options, ExtQueryArgs, ExtResult>[]>, '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}. Includes:
 *
 * - One entry per (sliced) model under its uncapitalized name, providing the per-model
 *   {@link ModelQueryHooks} (e.g. `client.user.useFindMany`, `client.user.useCreate`).
 * - A `$procs` namespace with hooks for any custom procedures declared in the schema.
 * - A `$transaction.useSequential` hook for executing a sequential transaction.
 */
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?: Omit<UseMutationOptions<ProcedureReturn<Schema, Name>, DefaultError, ProcedureEnvelope<Schema, Name>>, 'mutationFn'> & QueryContext): UseMutationResult<ProcedureReturn<Schema, Name>, DefaultError, ProcedureEnvelope<Schema, Name>>;
    } : {
        useQuery: ProcedureHookFn<Schema, Name, Omit<ModelQueryOptions<ProcedureReturn<Schema, Name>>, 'optimisticUpdate'>, UseQueryResult<ProcedureReturn<Schema, Name>, DefaultError> & {
            queryKey: QueryKey;
        }>;
        useSuspenseQuery: ProcedureHookFn<Schema, Name, Omit<ModelSuspenseQueryOptions<ProcedureReturn<Schema, Name>>, 'optimisticUpdate'>, UseSuspenseQueryResult<ProcedureReturn<Schema, Name>, DefaultError> & {
            queryKey: 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: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>, options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
    useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>, options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
    useFindFirst<T extends FindFirstArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>, options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
    useSuspenseFindFirst<T extends FindFirstArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>, options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
    useExists<T extends ExistsArgs<Schema, Model, Options, ExtQueryArgs>>(args?: Subset<T, ExistsArgs<Schema, Model, Options, ExtQueryArgs>>, options?: ModelQueryOptions<boolean>): ModelQueryResult<boolean>;
    useFindMany<T extends FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>, options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
    useSuspenseFindMany<T extends FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>, options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
    useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>, TPageParam = unknown>(args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>, options?: ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], TPageParam>): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], TPageParam>>;
    useSuspenseInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>, TPageParam = unknown>(args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>, options?: ModelSuspenseInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], TPageParam>): ModelSuspenseInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], TPageParam>>;
    useCreate<T extends CreateArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
    useCreateMany<T extends CreateManyArgs<Schema, Model, Options, ExtQueryArgs>>(options?: ModelMutationOptions<BatchResult, T>): ModelMutationResult<BatchResult, T>;
    useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(options?: 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?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
    useUpdateMany<T extends UpdateManyArgs<Schema, Model, Options, ExtQueryArgs>>(options?: ModelMutationOptions<BatchResult, T>): ModelMutationResult<BatchResult, T>;
    useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(options?: 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?: 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?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
    useDeleteMany<T extends DeleteManyArgs<Schema, Model, Options, ExtQueryArgs>>(options?: ModelMutationOptions<BatchResult, T>): ModelMutationResult<BatchResult, T>;
    useCount<T extends CountArgs<Schema, Model, Options, ExtQueryArgs>>(args?: Subset<T, CountArgs<Schema, Model, Options, ExtQueryArgs>>, options?: ModelQueryOptions<CountResult<Schema, Model, T>>): ModelQueryResult<CountResult<Schema, Model, T>>;
    useSuspenseCount<T extends CountArgs<Schema, Model, Options, ExtQueryArgs>>(args?: Subset<T, CountArgs<Schema, Model, Options, ExtQueryArgs>>, options?: ModelSuspenseQueryOptions<CountResult<Schema, Model, T>>): ModelSuspenseQueryResult<CountResult<Schema, Model, T>>;
    useAggregate<T extends AggregateArgs<Schema, Model, Options, ExtQueryArgs>>(args: Subset<T, AggregateArgs<Schema, Model, Options, ExtQueryArgs>>, options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>): ModelQueryResult<AggregateResult<Schema, Model, T>>;
    useSuspenseAggregate<T extends AggregateArgs<Schema, Model, Options, ExtQueryArgs>>(args: Subset<T, AggregateArgs<Schema, Model, Options, ExtQueryArgs>>, options?: ModelSuspenseQueryOptions<AggregateResult<Schema, Model, T>>): ModelSuspenseQueryResult<AggregateResult<Schema, Model, T>>;
    useGroupBy<T extends GroupByArgs<Schema, Model, Options, ExtQueryArgs>>(args: Subset<T, GroupByArgs<Schema, Model, Options, ExtQueryArgs>>, options?: ModelQueryOptions<GroupByResult<Schema, Model, T>>): ModelQueryResult<GroupByResult<Schema, Model, T>>;
    useSuspenseGroupBy<T extends GroupByArgs<Schema, Model, Options, ExtQueryArgs>>(args: Subset<T, GroupByArgs<Schema, Model, Options, ExtQueryArgs>>, options?: ModelSuspenseQueryOptions<GroupByResult<Schema, Model, T>>): ModelSuspenseQueryResult<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)
 * ```
 *
 * @param schema The schema.
 * @param options Options for all queries originated from this hook.
 */
export declare function useClientQueries<SchemaOrClient extends SchemaDef | ClientContract<any, any, any, any, any>>(schema: InferSchema<SchemaOrClient>, options?: 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?: QueryContext): ModelQueryHooks<Schema, Model, Options, ExtQueryArgs, ExtResult>;
export declare function useInternalQuery<TQueryFnData, TData>(_schema: SchemaDef, model: string, operation: string, args?: unknown, options?: Omit<UseQueryOptions<TQueryFnData, DefaultError, TData>, 'queryKey'> & ExtraQueryOptions): {
    data: import("@tanstack/query-core").NoInfer<TData>;
    error: Error;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    isPlaceholderData: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@tanstack/query-core").NoInfer<TData>, Error>>;
    fetchStatus: import("@tanstack/query-core").FetchStatus;
    promise: Promise<import("@tanstack/query-core").NoInfer<TData>>;
    queryKey: import("./common/query-key.js").QueryKey;
} | {
    data: import("@tanstack/query-core").NoInfer<TData>;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    isPlaceholderData: false;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@tanstack/query-core").NoInfer<TData>, Error>>;
    fetchStatus: import("@tanstack/query-core").FetchStatus;
    promise: Promise<import("@tanstack/query-core").NoInfer<TData>>;
    queryKey: import("./common/query-key.js").QueryKey;
} | {
    data: undefined;
    error: Error;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@tanstack/query-core").NoInfer<TData>, Error>>;
    fetchStatus: import("@tanstack/query-core").FetchStatus;
    promise: Promise<import("@tanstack/query-core").NoInfer<TData>>;
    queryKey: import("./common/query-key.js").QueryKey;
} | {
    data: undefined;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@tanstack/query-core").NoInfer<TData>, Error>>;
    fetchStatus: import("@tanstack/query-core").FetchStatus;
    promise: Promise<import("@tanstack/query-core").NoInfer<TData>>;
    queryKey: import("./common/query-key.js").QueryKey;
} | {
    data: undefined;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "pending";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@tanstack/query-core").NoInfer<TData>, Error>>;
    fetchStatus: import("@tanstack/query-core").FetchStatus;
    promise: Promise<import("@tanstack/query-core").NoInfer<TData>>;
    queryKey: import("./common/query-key.js").QueryKey;
} | {
    data: import("@tanstack/query-core").NoInfer<TData>;
    isError: false;
    error: null;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    isPlaceholderData: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("@tanstack/query-core").NoInfer<TData>, Error>>;
    fetchStatus: import("@tanstack/query-core").FetchStatus;
    promise: Promise<import("@tanstack/query-core").NoInfer<TData>>;
    queryKey: import("./common/query-key.js").QueryKey;
};
export declare function useInternalSuspenseQuery<TQueryFnData, TData>(_schema: SchemaDef, model: string, operation: string, args?: unknown, options?: Omit<UseSuspenseQueryOptions<TQueryFnData, DefaultError, TData>, 'queryKey'> & ExtraQueryOptions): {
    data: TData;
    error: Error;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    status: "error";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TData, Error>>;
    fetchStatus: import("@tanstack/query-core").FetchStatus;
    queryKey: import("./common/query-key.js").QueryKey;
} | {
    data: TData;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    status: "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TData, Error>>;
    fetchStatus: import("@tanstack/query-core").FetchStatus;
    queryKey: import("./common/query-key.js").QueryKey;
};
export declare function useInternalInfiniteQuery<TQueryFnData, TData, TPageParam = unknown>(_schema: SchemaDef, model: string, operation: string, args: unknown, options: (Omit<UseInfiniteQueryOptions<TQueryFnData, DefaultError, InfiniteData<TData, TPageParam>, QueryKey, TPageParam>, 'queryKey' | 'initialPageParam'> & QueryContext) | undefined): {
    data: InfiniteData<TData, TPageParam>;
    error: Error;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    isPlaceholderData: false;
    status: "error";
    fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    hasNextPage: boolean;
    hasPreviousPage: boolean;
    isFetchNextPageError: boolean;
    isFetchingNextPage: boolean;
    isFetchPreviousPageError: boolean;
    isFetchingPreviousPage: boolean;
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    fetchStatus: import("@tanstack/query-core").FetchStatus;
    promise: Promise<InfiniteData<TData, TPageParam>>;
    queryKey: import("./common/query-key.js").QueryKey;
} | {
    data: InfiniteData<TData, TPageParam>;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isFetchNextPageError: false;
    isFetchPreviousPageError: false;
    isSuccess: true;
    isPlaceholderData: false;
    status: "success";
    fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    hasNextPage: boolean;
    hasPreviousPage: boolean;
    isFetchingNextPage: boolean;
    isFetchingPreviousPage: boolean;
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    fetchStatus: import("@tanstack/query-core").FetchStatus;
    promise: Promise<InfiniteData<TData, TPageParam>>;
    queryKey: import("./common/query-key.js").QueryKey;
} | {
    data: undefined;
    error: Error;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isFetchNextPageError: false;
    isFetchPreviousPageError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "error";
    fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    hasNextPage: boolean;
    hasPreviousPage: boolean;
    isFetchingNextPage: boolean;
    isFetchingPreviousPage: boolean;
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    fetchStatus: import("@tanstack/query-core").FetchStatus;
    promise: Promise<InfiniteData<TData, TPageParam>>;
    queryKey: import("./common/query-key.js").QueryKey;
} | {
    data: undefined;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isFetchNextPageError: false;
    isFetchPreviousPageError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "pending";
    fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    hasNextPage: boolean;
    hasPreviousPage: boolean;
    isFetchingNextPage: boolean;
    isFetchingPreviousPage: boolean;
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    fetchStatus: import("@tanstack/query-core").FetchStatus;
    promise: Promise<InfiniteData<TData, TPageParam>>;
    queryKey: import("./common/query-key.js").QueryKey;
} | {
    data: undefined;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isFetchNextPageError: false;
    isFetchPreviousPageError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: "pending";
    fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    hasNextPage: boolean;
    hasPreviousPage: boolean;
    isFetchingNextPage: boolean;
    isFetchingPreviousPage: boolean;
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    fetchStatus: import("@tanstack/query-core").FetchStatus;
    promise: Promise<InfiniteData<TData, TPageParam>>;
    queryKey: import("./common/query-key.js").QueryKey;
} | {
    data: InfiniteData<TData, TPageParam>;
    isError: false;
    error: null;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    isPlaceholderData: true;
    isFetchNextPageError: false;
    isFetchPreviousPageError: false;
    status: "success";
    fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    hasNextPage: boolean;
    hasPreviousPage: boolean;
    isFetchingNextPage: boolean;
    isFetchingPreviousPage: boolean;
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    fetchStatus: import("@tanstack/query-core").FetchStatus;
    promise: Promise<InfiniteData<TData, TPageParam>>;
    queryKey: import("./common/query-key.js").QueryKey;
};
export declare function useInternalSuspenseInfiniteQuery<TQueryFnData, TData, TPageParam = unknown>(_schema: SchemaDef, model: string, operation: string, args: unknown, options: Omit<UseSuspenseInfiniteQueryOptions<TQueryFnData, DefaultError, InfiniteData<TData, TPageParam>, QueryKey, TPageParam> & QueryContext, 'queryKey' | 'initialPageParam'>): {
    data: InfiniteData<TData, TPageParam>;
    error: Error | null;
    isError: boolean;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: boolean;
    isSuccess: boolean;
    status: "error" | "success";
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    fetchStatus: import("@tanstack/query-core").FetchStatus;
    fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<TData, TPageParam>, Error>>;
    hasNextPage: boolean;
    hasPreviousPage: boolean;
    isFetchNextPageError: boolean;
    isFetchingNextPage: boolean;
    isFetchPreviousPageError: boolean;
    isFetchingPreviousPage: boolean;
    queryKey: import("./common/query-key.js").QueryKey;
};
/**
 * Creates a react-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 react-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?: Omit<UseMutationOptions<R, DefaultError, TArgs>, 'mutationFn'> & ExtraMutationOptions): UseMutationResult<R, Error, TArgs, unknown>;
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>;