@zenstackhq/tanstack-query 2.21.0 → 3.0.0-beta.16

package/dist/react.d.ts

@@ -0,0 +1,696 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseQueryOptions, DefaultError, UseQueryResult, QueryKey, UseSuspenseQueryOptions, UseSuspenseQueryResult, UseInfiniteQueryOptions, InfiniteData, UseInfiniteQueryResult, UseSuspenseInfiniteQueryOptions, UseSuspenseInfiniteQueryResult, UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import * as react from 'react';
+import { FindUniqueArgs, SelectSubset, ModelResult, FindArgs, CreateArgs, CreateManyArgs, BatchResult, CreateManyAndReturnArgs, UpdateArgs, UpdateManyArgs, UpdateManyAndReturnArgs, UpsertArgs, DeleteArgs, DeleteManyArgs, CountArgs, CountResult, AggregateArgs, AggregateResult, GroupByArgs, GroupByResult } from '@zenstackhq/orm';
+import { SchemaDef, GetModels } from '@zenstackhq/schema';
+
+/**
+ * Function signature for `fetch`.
+ */
+type FetchFn = (url: string, options?: RequestInit) => Promise<Response>;
+/**
+ * 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>;
+/**
+ * Extra mutation options.
+ */
+type ExtraMutationOptions = {
+    /**
+     * Whether to automatically invalidate queries potentially affected by the mutation. Defaults to `true`.
+     */
+    invalidateQueries?: boolean;
+    /**
+     * Whether to optimistically update queries potentially affected by the mutation. Defaults to `false`.
+     */
+    optimisticUpdate?: boolean;
+    /**
+     * A callback for computing optimistic update data for each query cache entry.
+     */
+    optimisticDataProvider?: OptimisticDataProvider;
+};
+/**
+ * Extra query options.
+ */
+type ExtraQueryOptions = {
+    /**
+     * Whether to opt-in to optimistic updates for this query. Defaults to `true`.
+     */
+    optimisticUpdate?: boolean;
+};
+/**
+ * Context type for configuring the hooks.
+ */
+type APIContext = {
+    /**
+     * 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;
+};
+
+/**
+ * The default query endpoint.
+ */
+declare const DEFAULT_QUERY_ENDPOINT = "/api/model";
+/**
+ * React context for query settings.
+ */
+declare const QuerySettingsContext: react.Context<APIContext>;
+/**
+ * React context provider for configuring query settings.
+ */
+declare const QuerySettingsProvider: react.Provider<APIContext>;
+/**
+ * React context provider for configuring query settings.
+ *
+ * @deprecated Use `QuerySettingsProvider` instead.
+ */
+declare const Provider: react.Provider<APIContext>;
+type ModelQueryOptions<T> = Omit<UseQueryOptions<T, DefaultError>, 'queryKey'> & ExtraQueryOptions;
+type ModelQueryResult<T> = UseQueryResult<T, DefaultError> & {
+    queryKey: QueryKey;
+};
+type ModelSuspenseQueryOptions<T> = Omit<UseSuspenseQueryOptions<T, DefaultError>, 'queryKey'> & ExtraQueryOptions;
+type ModelSuspenseQueryResult<T> = UseSuspenseQueryResult<T, DefaultError> & {
+    queryKey: QueryKey;
+};
+type ModelInfiniteQueryOptions<T> = Omit<UseInfiniteQueryOptions<T, DefaultError, InfiniteData<T>>, 'queryKey' | 'initialPageParam'>;
+type ModelInfiniteQueryResult<T> = UseInfiniteQueryResult<T, DefaultError> & {
+    queryKey: QueryKey;
+};
+type ModelSuspenseInfiniteQueryOptions<T> = Omit<UseSuspenseInfiniteQueryOptions<T, DefaultError, InfiniteData<T>>, 'queryKey' | 'initialPageParam'>;
+type ModelSuspenseInfiniteQueryResult<T> = UseSuspenseInfiniteQueryResult<T, DefaultError> & {
+    queryKey: QueryKey;
+};
+type ModelMutationOptions<T, TArgs> = Omit<UseMutationOptions<T, DefaultError, TArgs>, 'mutationFn'> & ExtraMutationOptions;
+type ModelMutationResult<T, TArgs> = UseMutationResult<T, DefaultError, TArgs>;
+type SchemaHooks<Schema extends SchemaDef> = {
+    [Model in GetModels<Schema> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model>;
+};
+type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    useFindUnique<T extends FindUniqueArgs<Schema, Model>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model>>, options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
+    useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model>>, options?: ModelSuspenseQueryOptions<ModelResult<Schema, Model, T> | null>): ModelSuspenseQueryResult<ModelResult<Schema, Model, T> | null>;
+    useFindFirst<T extends FindArgs<Schema, Model, false>>(args?: SelectSubset<T, FindArgs<Schema, Model, false>>, options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
+    useSuspenseFindFirst<T extends FindArgs<Schema, Model, false>>(args?: SelectSubset<T, FindArgs<Schema, Model, false>>, options?: ModelSuspenseQueryOptions<ModelResult<Schema, Model, T> | null>): ModelSuspenseQueryResult<ModelResult<Schema, Model, T> | null>;
+    useFindMany<T extends FindArgs<Schema, Model, true>>(args?: SelectSubset<T, FindArgs<Schema, Model, true>>, options?: ModelQueryOptions<ModelResult<Schema, Model, T>[]>): ModelQueryResult<ModelResult<Schema, Model, T>[]>;
+    useSuspenseFindMany<T extends FindArgs<Schema, Model, true>>(args?: SelectSubset<T, FindArgs<Schema, Model, true>>, options?: ModelSuspenseQueryOptions<ModelResult<Schema, Model, T>[]>): ModelSuspenseQueryResult<ModelResult<Schema, Model, T>[]>;
+    useInfiniteFindMany<T extends FindArgs<Schema, Model, true>>(args?: SelectSubset<T, FindArgs<Schema, Model, true>>, options?: ModelInfiniteQueryOptions<ModelResult<Schema, Model, T>[]>): ModelInfiniteQueryResult<InfiniteData<ModelResult<Schema, Model, T>[]>>;
+    useSuspenseInfiniteFindMany<T extends FindArgs<Schema, Model, true>>(args?: SelectSubset<T, FindArgs<Schema, Model, true>>, options?: ModelSuspenseInfiniteQueryOptions<ModelResult<Schema, Model, T>[]>): ModelSuspenseInfiniteQueryResult<InfiniteData<ModelResult<Schema, Model, T>[]>>;
+    useCreate<T extends CreateArgs<Schema, Model>>(options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
+    useCreateMany<T extends CreateManyArgs<Schema, Model>>(options?: ModelMutationOptions<BatchResult, T>): ModelMutationResult<BatchResult, T>;
+    useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>): ModelMutationResult<ModelResult<Schema, Model, T>[], T>;
+    useUpdate<T extends UpdateArgs<Schema, Model>>(options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
+    useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(options?: ModelMutationOptions<BatchResult, T>): ModelMutationResult<BatchResult, T>;
+    useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>): ModelMutationResult<ModelResult<Schema, Model, T>[], T>;
+    useUpsert<T extends UpsertArgs<Schema, Model>>(options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
+    useDelete<T extends DeleteArgs<Schema, Model>>(options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
+    useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(options?: ModelMutationOptions<BatchResult, T>): ModelMutationResult<BatchResult, T>;
+    useCount<T extends CountArgs<Schema, Model>>(options?: ModelQueryOptions<CountResult<Schema, Model, T>>): ModelQueryResult<CountResult<Schema, Model, T>>;
+    useSuspenseCount<T extends CountArgs<Schema, Model>>(options?: ModelSuspenseQueryOptions<CountResult<Schema, Model, T>>): ModelSuspenseQueryResult<CountResult<Schema, Model, T>>;
+    useAggregate<T extends AggregateArgs<Schema, Model>>(options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>): ModelQueryResult<AggregateResult<Schema, Model, T>>;
+    useSuspenseAggregate<T extends AggregateArgs<Schema, Model>>(options?: ModelSuspenseQueryOptions<AggregateResult<Schema, Model, T>>): ModelSuspenseQueryResult<AggregateResult<Schema, Model, T>>;
+    useGroupBy<T extends GroupByArgs<Schema, Model>>(options?: ModelQueryOptions<GroupByResult<Schema, Model, T>>): ModelQueryResult<GroupByResult<Schema, Model, T>>;
+    useSuspenseGroupBy<T extends GroupByArgs<Schema, Model>>(options?: ModelSuspenseQueryOptions<GroupByResult<Schema, Model, T>>): ModelSuspenseQueryResult<GroupByResult<Schema, Model, T>>;
+};
+/**
+ * Gets data query hooks for all models in the schema.
+ */
+declare function useClientQueries<Schema extends SchemaDef>(schema: Schema): SchemaHooks<Schema>;
+/**
+ * Gets data query hooks for a specific model in the schema.
+ */
+declare function useModelQueries<Schema extends SchemaDef, Model extends GetModels<Schema>>(schema: Schema, model: Model): ModelQueryHooks<Schema, Model>;
+declare function useInternalQuery<TQueryFnData, TData>(_schema: SchemaDef, model: string, operation: string, args?: unknown, options?: Omit<UseQueryOptions<TQueryFnData, DefaultError, TData>, 'queryKey'> & ExtraQueryOptions): {
+    data: _tanstack_react_query.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?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_tanstack_react_query.NoInfer<TData>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<_tanstack_react_query.NoInfer<TData>>;
+    queryKey: [string, string, string, unknown, {
+        infinite: boolean;
+        optimisticUpdate: boolean;
+    }];
+} | {
+    data: _tanstack_react_query.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?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_tanstack_react_query.NoInfer<TData>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<_tanstack_react_query.NoInfer<TData>>;
+    queryKey: [string, string, string, unknown, {
+        infinite: boolean;
+        optimisticUpdate: boolean;
+    }];
+} | {
+    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?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_tanstack_react_query.NoInfer<TData>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<_tanstack_react_query.NoInfer<TData>>;
+    queryKey: [string, string, string, unknown, {
+        infinite: boolean;
+        optimisticUpdate: boolean;
+    }];
+} | {
+    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?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_tanstack_react_query.NoInfer<TData>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<_tanstack_react_query.NoInfer<TData>>;
+    queryKey: [string, string, string, unknown, {
+        infinite: boolean;
+        optimisticUpdate: boolean;
+    }];
+} | {
+    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?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_tanstack_react_query.NoInfer<TData>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<_tanstack_react_query.NoInfer<TData>>;
+    queryKey: [string, string, string, unknown, {
+        infinite: boolean;
+        optimisticUpdate: boolean;
+    }];
+} | {
+    data: _tanstack_react_query.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?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_tanstack_react_query.NoInfer<TData>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<_tanstack_react_query.NoInfer<TData>>;
+    queryKey: [string, string, string, unknown, {
+        infinite: boolean;
+        optimisticUpdate: boolean;
+    }];
+};
+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?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<TData, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    queryKey: [string, string, string, unknown, {
+        infinite: boolean;
+        optimisticUpdate: boolean;
+    }];
+} | {
+    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?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<TData, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    queryKey: [string, string, string, unknown, {
+        infinite: boolean;
+        optimisticUpdate: boolean;
+    }];
+};
+declare function useInternalInfiniteQuery<TQueryFnData, TData>(_schema: SchemaDef, model: string, operation: string, args: unknown, options: Omit<UseInfiniteQueryOptions<TQueryFnData, DefaultError, InfiniteData<TData>>, 'queryKey' | 'initialPageParam'>): {
+    data: InfiniteData<TData, unknown>;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<TData, unknown>, Error>>;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<TData, unknown>, 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?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<InfiniteData<TData, unknown>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<InfiniteData<TData, unknown>>;
+    queryKey: [string, string, string, unknown, {
+        infinite: boolean;
+        optimisticUpdate: boolean;
+    }];
+} | {
+    data: InfiniteData<TData, unknown>;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<TData, unknown>, Error>>;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<TData, unknown>, 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?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<InfiniteData<TData, unknown>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<InfiniteData<TData, unknown>>;
+    queryKey: [string, string, string, unknown, {
+        infinite: boolean;
+        optimisticUpdate: boolean;
+    }];
+} | {
+    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?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<TData, unknown>, Error>>;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<TData, unknown>, 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?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<InfiniteData<TData, unknown>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<InfiniteData<TData, unknown>>;
+    queryKey: [string, string, string, unknown, {
+        infinite: boolean;
+        optimisticUpdate: boolean;
+    }];
+} | {
+    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?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<TData, unknown>, Error>>;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<TData, unknown>, 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?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<InfiniteData<TData, unknown>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<InfiniteData<TData, unknown>>;
+    queryKey: [string, string, string, unknown, {
+        infinite: boolean;
+        optimisticUpdate: boolean;
+    }];
+} | {
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<TData, unknown>, Error>>;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<TData, unknown>, 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?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<InfiniteData<TData, unknown>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<InfiniteData<TData, unknown>>;
+    queryKey: [string, string, string, unknown, {
+        infinite: boolean;
+        optimisticUpdate: boolean;
+    }];
+} | {
+    data: InfiniteData<TData, unknown>;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    status: "success";
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<TData, unknown>, Error>>;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<TData, unknown>, 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?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<InfiniteData<TData, unknown>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    promise: Promise<InfiniteData<TData, unknown>>;
+    queryKey: [string, string, string, unknown, {
+        infinite: boolean;
+        optimisticUpdate: boolean;
+    }];
+};
+declare function useInternalSuspenseInfiniteQuery<TQueryFnData, TData>(_schema: SchemaDef, model: string, operation: string, args: unknown, options: Omit<UseSuspenseInfiniteQueryOptions<TQueryFnData, DefaultError, InfiniteData<TData>>, 'queryKey' | 'initialPageParam'>): {
+    data: InfiniteData<TData, unknown>;
+    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?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<InfiniteData<TData, unknown>, Error>>;
+    fetchStatus: _tanstack_react_query.FetchStatus;
+    fetchNextPage: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<TData, unknown>, Error>>;
+    fetchPreviousPage: (options?: _tanstack_react_query.FetchPreviousPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<InfiniteData<TData, unknown>, Error>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchNextPageError: boolean;
+    isFetchingNextPage: boolean;
+    isFetchPreviousPageError: boolean;
+    isFetchingPreviousPage: boolean;
+    queryKey: [string, string, string, unknown, {
+        infinite: boolean;
+        optimisticUpdate: boolean;
+    }];
+};
+/**
+ * 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.
+ */
+declare function useInternalMutation<TArgs, R = any, C extends boolean = boolean, Result = C extends true ? R | undefined : R>(schema: SchemaDef, model: string, method: 'POST' | 'PUT' | 'DELETE', operation: string, options?: Omit<UseMutationOptions<Result, DefaultError, TArgs>, 'mutationFn'> & ExtraMutationOptions, checkReadBack?: C): UseMutationResult<Result, Error, TArgs, unknown>;
+
+export { DEFAULT_QUERY_ENDPOINT, type FetchFn, type ModelInfiniteQueryOptions, type ModelInfiniteQueryResult, type ModelMutationOptions, type ModelMutationResult, type ModelQueryHooks, type ModelQueryOptions, type ModelQueryResult, type ModelSuspenseInfiniteQueryOptions, type ModelSuspenseInfiniteQueryResult, type ModelSuspenseQueryOptions, type ModelSuspenseQueryResult, Provider, QuerySettingsContext, QuerySettingsProvider, type SchemaHooks, useClientQueries, useInternalInfiniteQuery, useInternalMutation, useInternalQuery, useInternalSuspenseInfiniteQuery, useInternalSuspenseQuery, useModelQueries };