import * as swr_mutation from 'swr/mutation';
import { SWRMutationConfiguration } from 'swr/mutation';
import * as react from 'react';
import { ModelMeta } from '@zenstackhq/runtime/cross';
import { SWRConfiguration, Fetcher, SWRResponse } from 'swr';
import { ScopedMutator } from 'swr/_internal';
import { SWRInfiniteConfiguration, SWRInfiniteFetcher, SWRInfiniteResponse } from 'swr/infinite';

type Enumerable<T> = T | Array<T>;
type _TupleToUnion<T> = T extends (infer E)[] ? E : never;
type TupleToUnion<K extends readonly any[]> = _TupleToUnion<K>;
type MaybeTupleToUnion<T> = T extends any[] ? TupleToUnion<T> : T;
type PickEnumerable<T, K extends Enumerable<keyof T> | keyof T> = Pick<T, MaybeTupleToUnion<K>>;
type SelectAndInclude = {
    select: any;
    include: any;
};
type HasSelect = {
    select: any;
};
type HasInclude = {
    include: any;
};
type CheckSelect<T, S, U> = T extends SelectAndInclude ? 'Please either choose `select` or `include`' : T extends HasSelect ? U : T extends HasInclude ? U : S;

/**
 * Function signature for `fetch`.
 */
type FetchFn = (url: string, options?: RequestInit) => Promise<Response>;
/**
 * Context type for configuring react hooks.
 */
type RequestHandlerContext = {
    /**
     * The endpoint to use for the queries.
     */
    endpoint?: string;
    /**
     * A custom fetch function for sending the HTTP requests.
     */
    fetch?: FetchFn;
    /**
     * If logging is enabled.
     */
    logging?: boolean;
};
/**
 * Context for configuring react hooks.
 */
declare const RequestHandlerContext: react.Context<RequestHandlerContext>;
/**
 * Context provider.
 */
declare const Provider: react.Provider<RequestHandlerContext>;
/**
 * Hooks context.
 */
declare function useHooksContext(): {
    /**
     * A custom fetch function for sending the HTTP requests.
     */
    fetch?: FetchFn;
    /**
     * If logging is enabled.
     */
    logging?: boolean;
    endpoint: string;
};
/**
 * Regular query options.
 */
type QueryOptions<Result, Error = unknown> = {
    /**
     * Disable data fetching
     */
    disabled?: boolean;
    /**
     * Whether to enable automatic optimistic update. Defaults to `true`.
     */
    optimisticUpdate?: boolean;
} & Omit<SWRConfiguration<Result, Error, Fetcher<Result>>, 'fetcher'>;
/**
 * Infinite query options.
 */
type InfiniteQueryOptions<Result, Error = unknown> = {
    /**
     * Disable data fetching
     */
    disabled?: boolean;
} & Omit<SWRInfiniteConfiguration<Result, Error, SWRInfiniteFetcher<Result>>, 'fetcher'>;
/**
 * Result of optimistic data provider.
 */
type OptimisticDataProviderResult = {
    /**
     * Kind of the result.
     *   - Update: use the `data` field to update the query cache.
     *   - Skip: skip the optimistic update for this query.
     *   - ProceedDefault: proceed with the default optimistic update.
     */
    kind: 'Update' | 'Skip' | 'ProceedDefault';
    /**
     * Data to update the query cache. Only applicable if `kind` is 'Update'.
     *
     * If the data is an object with fields updated, it should have a `$optimistic`
     * field set to `true`. If it's an array and an element object is created or updated,
     * the element should have a `$optimistic` field set to `true`.
     */
    data?: any;
};
/**
 * Optimistic data provider.
 *
 * @param args Arguments.
 * @param args.queryModel The model of the query.
 * @param args.queryOperation The operation of the query, `findMany`, `count`, etc.
 * @param args.queryArgs The arguments of the query.
 * @param args.currentData The current cache data for the query.
 * @param args.mutationArgs The arguments of the mutation.
 */
type OptimisticDataProvider = (args: {
    queryModel: string;
    queryOperation: string;
    queryArgs: any;
    currentData: any;
    mutationArgs: any;
}) => OptimisticDataProviderResult | Promise<OptimisticDataProviderResult>;
/**
 * Mutation options.
 */
type MutationOptions<Result, Error, Args> = {
    /**
     * Whether to automatically optimistic-update queries potentially impacted. Defaults to `false`.
     */
    optimisticUpdate?: boolean;
    /**
     * A callback for computing optimistic update data for each query cache entry.
     */
    optimisticDataProvider?: OptimisticDataProvider;
} & Omit<SWRMutationConfiguration<Result, Error, string, Args>, 'fetcher'>;
/**
 * Computes query key for the given model, operation, query args, and options.
 */
declare function getQueryKey(model: string, operation: string, args?: unknown, infinite?: boolean, optimisticUpdate?: boolean): string;
/**
 * Makes a model query with SWR.
 *
 * @param model Model name
 * @param operation Prisma operation (e.g, `findMany`)
 * @param args The request args object, which will be superjson-stringified and appended as "?q=" parameter
 * @param options Query options
 * @returns SWR response
 */
declare function useModelQuery<Result, Error = unknown>(model: string, operation: string, args?: unknown, options?: QueryOptions<Result, Error>): SWRResponse<Result, Error>;
/**
 * Function for computing the query args for fetching a page during an infinite query.
 */
type GetNextArgs<Args, Result> = (pageIndex: number, previousPageData: Result | null) => Args | null;
/**
 * Makes an infinite GET request with SWR.
 *
 * @param model Model name
 * @param operation Prisma operation (e.g, `findMany`)
 * @param getNextArgs Function for computing the query args for a page
 * @param options Query options
 * @returns SWR infinite query response
 */
declare function useInfiniteModelQuery<Args, Result, Error = unknown>(model: string, operation: string, getNextArgs: GetNextArgs<Args, any>, options?: InfiniteQueryOptions<Result, Error>): SWRInfiniteResponse<Result, Error>;
declare function useModelMutation<Args, Result, CheckReadBack extends boolean = boolean>(model: string, method: 'POST' | 'PUT' | 'DELETE', operation: string, modelMeta: ModelMeta, options?: MutationOptions<CheckReadBack extends true ? Result | undefined : Result, unknown, Args>, checkReadBack?: CheckReadBack): swr_mutation.SWRMutationResponse<CheckReadBack extends true ? Result | undefined : Result, unknown, string, Args>;
/**
 * Makes a mutation request.
 *
 * @param url The request URL
 * @param data The request data
 * @param invalidate Function for invalidating a query
 */
declare function mutationRequest<Result, C extends boolean = boolean>(method: 'POST' | 'PUT' | 'DELETE', url: string, data: unknown, invalidate?: Invalidator, fetch?: FetchFn, checkReadBack?: C): Promise<C extends true ? Result | undefined : Result>;
type Invalidator = (operation: string, args?: unknown) => ReturnType<ScopedMutator>;
declare function useInvalidation(model: string, modelMeta: ModelMeta): Invalidator;
/**
 * Makes fetch request for queries and mutations.
 */
declare function fetcher<R, C extends boolean>(url: string, options?: RequestInit, customFetch?: FetchFn, checkReadBack?: C): Promise<C extends true ? R | undefined : R>;

export { type CheckSelect, type Enumerable, type FetchFn, type GetNextArgs, type InfiniteQueryOptions, type MaybeTupleToUnion, type MutationOptions, type OptimisticDataProvider, type OptimisticDataProviderResult, type PickEnumerable, Provider, type QueryOptions, RequestHandlerContext, type TupleToUnion, fetcher, getQueryKey, mutationRequest, useHooksContext, useInfiniteModelQuery, useInvalidation, useModelMutation, useModelQuery };