import { type Accessor, type CreateInfiniteQueryOptions, type CreateInfiniteQueryResult, type CreateMutationOptions, type CreateMutationResult, type CreateQueryOptions, type CreateQueryResult, type DefaultError, type InfiniteData, type QueryKey } from '@tanstack/svelte-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 { 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';
type ProcedureHookFn<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>, Options, Result, Input = ProcedureEnvelope<Schema, ProcName>> = {
    args: undefined;
} extends Input ? (args?: Accessor<Input>, options?: Accessor<Options>) => Result : (args: Accessor<Input>, options?: Accessor<Options>) => Result;
/**
 * Key for setting and getting the global query context.
 */
export declare const SvelteQueryContextKey = "zenstack-svelte-query-context";
/**
 * Set context for query settings.
 *
 * @deprecated use {@link setQuerySettingsContext} instead.
 */
export declare function setHooksContext(context: QueryContext): void;
/**
 * Set context for query settings.
 */
export declare function setQuerySettingsContext(context: QueryContext): void;
export type ModelQueryOptions<T> = Omit<CreateQueryOptions<T, DefaultError>, 'queryKey'> & ExtraQueryOptions;
export type ModelQueryResult<T> = CreateQueryResult<WithOptimistic<T>, DefaultError> & {
    queryKey: QueryKey;
};
export type ModelInfiniteQueryOptions<T, TPageParam = unknown> = Omit<CreateInfiniteQueryOptions<T, DefaultError, InfiniteData<T, TPageParam>, QueryKey, TPageParam>, 'queryKey' | 'initialPageParam'> & QueryContext;
export type ModelInfiniteQueryResult<T> = CreateInfiniteQueryResult<T, DefaultError> & {
    queryKey: QueryKey;
};
export type ModelMutationOptions<T, TArgs> = Omit<CreateMutationOptions<T, DefaultError, TArgs>, 'mutationFn'> & ExtraMutationOptions;
export type ModelMutationResult<T, TArgs> = CreateMutationResult<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<CreateMutationOptions<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<CreateMutationResult<unknown[], DefaultError, TransactionOperation<Schema, Options, ExtQueryArgs, ExtResult>[]>, 'mutateAsync'> & {
    mutateAsync<const T extends readonly TransactionOperation<Schema, Options, ExtQueryArgs, ExtResult>[]>(operations: T, options?: Omit<CreateMutationOptions<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?: Omit<CreateMutationOptions<ProcedureReturn<Schema, Name>, DefaultError, ProcedureEnvelope<Schema, Name>>, 'mutationFn'> & QueryContext): CreateMutationResult<ProcedureReturn<Schema, Name>, DefaultError, ProcedureEnvelope<Schema, Name>>;
    } : {
        useQuery: ProcedureHookFn<Schema, Name, Omit<ModelQueryOptions<ProcedureReturn<Schema, Name>>, 'optimisticUpdate'>, CreateQueryResult<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: Accessor<SelectSubset<T, FindUniqueArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>>, options?: Accessor<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?: Accessor<SelectSubset<T, FindFirstArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>>, options?: Accessor<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?: Accessor<Subset<T, ExistsArgs<Schema, Model, Options, ExtQueryArgs>>>, options?: Accessor<ModelQueryOptions<boolean>>): ModelQueryResult<boolean>;
    useFindMany<T extends FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args?: Accessor<SelectSubset<T, FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>>, options?: Accessor<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?: Accessor<SelectSubset<T, FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>>, options?: Accessor<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?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
    useCreateMany<T extends CreateManyArgs<Schema, Model, Options, ExtQueryArgs>>(options?: Accessor<ModelMutationOptions<BatchResult, T>>): ModelMutationResult<BatchResult, T>;
    useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(options?: Accessor<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?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
    useUpdateMany<T extends UpdateManyArgs<Schema, Model, Options, ExtQueryArgs>>(options?: Accessor<ModelMutationOptions<BatchResult, T>>): ModelMutationResult<BatchResult, T>;
    useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(options?: Accessor<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?: Accessor<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?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
    useDeleteMany<T extends DeleteManyArgs<Schema, Model, Options, ExtQueryArgs>>(options?: Accessor<ModelMutationOptions<BatchResult, T>>): ModelMutationResult<BatchResult, T>;
    useCount<T extends CountArgs<Schema, Model, Options, ExtQueryArgs>>(args?: Accessor<Subset<T, CountArgs<Schema, Model, Options, ExtQueryArgs>>>, options?: Accessor<ModelQueryOptions<CountResult<Schema, Model, T>>>): ModelQueryResult<CountResult<Schema, Model, T>>;
    useAggregate<T extends AggregateArgs<Schema, Model, Options, ExtQueryArgs>>(args: Accessor<Subset<T, AggregateArgs<Schema, Model, Options, ExtQueryArgs>>>, options?: Accessor<ModelQueryOptions<AggregateResult<Schema, Model, T>>>): ModelQueryResult<AggregateResult<Schema, Model, T>>;
    useGroupBy<T extends GroupByArgs<Schema, Model, Options, ExtQueryArgs>>(args: Accessor<Subset<T, GroupByArgs<Schema, Model, Options, ExtQueryArgs>>>, options?: Accessor<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?: Accessor<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?: Accessor<QueryContext>): ModelQueryHooks<Schema, Model, Options, ExtQueryArgs, ExtResult>;
export declare function useInternalQuery<TQueryFnData, TData>(_schema: SchemaDef, model: string, operation: string, args?: Accessor<unknown>, options?: Accessor<Omit<CreateQueryOptions<TQueryFnData, DefaultError, TData>, 'queryKey'> & ExtraQueryOptions>): CreateQueryResult<TData, Error> & {
    queryKey: QueryKey;
};
export declare function useInternalInfiniteQuery<TQueryFnData, TData, TPageParam = unknown>(_schema: SchemaDef, model: string, operation: string, args?: Accessor<unknown>, options?: Accessor<Omit<CreateInfiniteQueryOptions<TQueryFnData, DefaultError, InfiniteData<TData, TPageParam>, QueryKey, TPageParam>, 'queryKey' | 'initialPageParam'> & QueryContext>): CreateInfiniteQueryResult<InfiniteData<TData, TPageParam>, Error> & {
    queryKey: QueryKey;
};
/**
 * Creates a svelte-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 svelte-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?: Accessor<Omit<CreateMutationOptions<R, DefaultError, TArgs>, 'mutationFn'> & ExtraMutationOptions>): CreateMutationResult<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?: Accessor<TransactionMutationOptions<Schema, Options, ExtQueryArgs, ExtResult>>): TransactionMutationResult<Schema, Options, ExtQueryArgs, ExtResult>;