@zenstackhq/tanstack-query 3.0.0 → 3.1.1

package/dist/vue.d.cts

@@ -1,382 +0,0 @@
-import * as _tanstack_vue_query from '@tanstack/vue-query';
-import { UseQueryOptions, DefaultError, UseQueryReturnType, QueryKey, UseInfiniteQueryOptions, InfiniteData, UseInfiniteQueryReturnType, UseMutationOptions, UseMutationReturnType } from '@tanstack/vue-query';
-import * as vue from 'vue';
-import { MaybeRefOrGetter, UnwrapRef } from 'vue';
-import { QueryOptions, SimplifiedResult, FindUniqueArgs, SelectSubset, SimplifiedPlainResult, FindFirstArgs, FindManyArgs, CreateArgs, CreateManyArgs, BatchResult, CreateManyAndReturnArgs, UpdateArgs, UpdateManyArgs, UpdateManyAndReturnArgs, UpsertArgs, DeleteArgs, DeleteManyArgs, CountArgs, Subset, CountResult, AggregateArgs, AggregateResult, GroupByArgs, GroupByResult } from '@zenstackhq/orm';
-import { SchemaDef, GetModels } from '@zenstackhq/schema';
-import { A as APIContext, E as ExtraQueryOptions, W as WithOptimistic, a as ExtraMutationOptions, T as TrimDelegateModelOperations } from './types-C8iIZD-7.cjs';
-export { F as FetchFn } from './types-C8iIZD-7.cjs';
-
-declare const VueQueryContextKey = "zenstack-vue-query-context";
-/**
- * Provide context for query settings.
- *
- * @deprecated Use {@link provideQuerySettingsContext} instead.
- */
-declare function provideHooksContext(context: APIContext): void;
-/**
- * Provide context for query settings.
- */
-declare function provideQuerySettingsContext(context: APIContext): void;
-type ModelQueryOptions<T> = MaybeRefOrGetter<Omit<UnwrapRef<UseQueryOptions<T, DefaultError>>, 'queryKey'> & ExtraQueryOptions>;
-type ModelQueryResult<T> = UseQueryReturnType<WithOptimistic<T>, DefaultError> & {
-    queryKey: QueryKey;
-};
-type ModelInfiniteQueryOptions<T> = MaybeRefOrGetter<Omit<UnwrapRef<UseInfiniteQueryOptions<T, DefaultError, InfiniteData<T>>>, 'queryKey' | 'initialPageParam'>>;
-type ModelInfiniteQueryResult<T> = UseInfiniteQueryReturnType<T, DefaultError> & {
-    queryKey: QueryKey;
-};
-type ModelMutationOptions<T, TArgs> = MaybeRefOrGetter<Omit<UnwrapRef<UseMutationOptions<T, DefaultError, TArgs>>, 'mutationFn'> & ExtraMutationOptions>;
-type ModelMutationResult<T, TArgs> = UseMutationReturnType<T, DefaultError, TArgs, unknown>;
-type ModelMutationModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, TArgs, Array extends boolean = false, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = Omit<ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, QueryOptions<Schema>, false, Array>, TArgs>, 'mutateAsync'> & {
-    mutateAsync<T extends TArgs>(args: T, options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array>, T>): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array>>;
-};
-type ClientHooks<Schema extends SchemaDef, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = {
-    [Model in GetModels<Schema> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options>;
-};
-type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = TrimDelegateModelOperations<Schema, Model, {
-    useFindUnique<T extends FindUniqueArgs<Schema, Model>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model>>, options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options> | null>): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options> | null>;
-    useFindFirst<T extends FindFirstArgs<Schema, Model>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model>>, options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options> | null>): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options> | null>;
-    useFindMany<T extends FindManyArgs<Schema, Model>>(args?: SelectSubset<T, FindManyArgs<Schema, Model>>, options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options>[]>): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options>[]>;
-    useInfiniteFindMany<T extends FindManyArgs<Schema, Model>>(args?: SelectSubset<T, FindManyArgs<Schema, Model>>, options?: ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options>[]>): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options>[]>>;
-    useCreate<T extends CreateArgs<Schema, Model>>(options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>): ModelMutationModelResult<Schema, Model, T, false, Options>;
-    useCreateMany<T extends CreateManyArgs<Schema, Model>>(options?: ModelMutationOptions<BatchResult, T>): ModelMutationResult<BatchResult, T>;
-    useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>[], T>): ModelMutationModelResult<Schema, Model, T, true, Options>;
-    useUpdate<T extends UpdateArgs<Schema, Model>>(options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>): ModelMutationModelResult<Schema, Model, T, false, Options>;
-    useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(options?: ModelMutationOptions<BatchResult, T>): ModelMutationResult<BatchResult, T>;
-    useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>[], T>): ModelMutationModelResult<Schema, Model, T, true, Options>;
-    useUpsert<T extends UpsertArgs<Schema, Model>>(options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>): ModelMutationModelResult<Schema, Model, T, false, Options>;
-    useDelete<T extends DeleteArgs<Schema, Model>>(options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>): ModelMutationModelResult<Schema, Model, T, false, Options>;
-    useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(options?: ModelMutationOptions<BatchResult, T>): ModelMutationResult<BatchResult, T>;
-    useCount<T extends CountArgs<Schema, Model>>(args?: Subset<T, CountArgs<Schema, Model>>, options?: ModelQueryOptions<CountResult<Schema, Model, T>>): ModelQueryResult<CountResult<Schema, Model, T>>;
-    useAggregate<T extends AggregateArgs<Schema, Model>>(args: Subset<T, AggregateArgs<Schema, Model>>, options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>): ModelQueryResult<AggregateResult<Schema, Model, T>>;
-    useGroupBy<T extends GroupByArgs<Schema, Model>>(args: Subset<T, GroupByArgs<Schema, Model>>, options?: ModelQueryOptions<GroupByResult<Schema, Model, T>>): ModelQueryResult<GroupByResult<Schema, Model, T>>;
-}>;
-/**
- * Gets data query hooks for all models in the schema.
- */
-declare function useClientQueries<Schema extends SchemaDef, Options extends QueryOptions<Schema> = QueryOptions<Schema>>(schema: Schema): ClientHooks<Schema, Options>;
-/**
- * Gets data query hooks for a specific model in the schema.
- */
-declare function useModelQueries<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>>(schema: Schema, model: Model): ModelQueryHooks<Schema, Model, Options>;
-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: vue.Ref<TData, TData>;
-    error: vue.Ref<Error, Error>;
-    isError: vue.Ref<true, true>;
-    isPending: vue.Ref<false, false>;
-    isLoading: vue.Ref<false, false>;
-    isLoadingError: vue.Ref<false, false>;
-    isRefetchError: vue.Ref<true, true>;
-    isSuccess: vue.Ref<false, false>;
-    isPlaceholderData: vue.Ref<false, false>;
-    status: vue.Ref<"error", "error">;
-    dataUpdatedAt: vue.Ref<number, number>;
-    errorUpdatedAt: vue.Ref<number, number>;
-    failureCount: vue.Ref<number, number>;
-    failureReason: vue.Ref<Error | null, Error | null>;
-    errorUpdateCount: vue.Ref<number, number>;
-    isFetched: vue.Ref<boolean, boolean>;
-    isFetchedAfterMount: vue.Ref<boolean, boolean>;
-    isFetching: vue.Ref<boolean, boolean>;
-    isInitialLoading: vue.Ref<boolean, boolean>;
-    isPaused: vue.Ref<boolean, boolean>;
-    isRefetching: vue.Ref<boolean, boolean>;
-    isStale: vue.Ref<boolean, boolean>;
-    isEnabled: vue.Ref<boolean, boolean>;
-    refetch: (options?: _tanstack_vue_query.RefetchOptions) => Promise<_tanstack_vue_query.QueryObserverResult<TData, Error>>;
-    fetchStatus: vue.Ref<_tanstack_vue_query.FetchStatus, _tanstack_vue_query.FetchStatus>;
-    promise: vue.Ref<Promise<TData>, Promise<TData>>;
-    suspense: () => Promise<_tanstack_vue_query.DefinedQueryObserverResult<TData, Error>>;
-    queryKey: [string, string, string, unknown, {
-        infinite: boolean;
-        optimisticUpdate: boolean;
-    }];
-} | {
-    data: vue.Ref<TData, TData>;
-    error: vue.Ref<null, null>;
-    isError: vue.Ref<false, false>;
-    isPending: vue.Ref<false, false>;
-    isLoading: vue.Ref<false, false>;
-    isLoadingError: vue.Ref<false, false>;
-    isRefetchError: vue.Ref<false, false>;
-    isSuccess: vue.Ref<true, true>;
-    isPlaceholderData: vue.Ref<false, false>;
-    status: vue.Ref<"success", "success">;
-    dataUpdatedAt: vue.Ref<number, number>;
-    errorUpdatedAt: vue.Ref<number, number>;
-    failureCount: vue.Ref<number, number>;
-    failureReason: vue.Ref<Error | null, Error | null>;
-    errorUpdateCount: vue.Ref<number, number>;
-    isFetched: vue.Ref<boolean, boolean>;
-    isFetchedAfterMount: vue.Ref<boolean, boolean>;
-    isFetching: vue.Ref<boolean, boolean>;
-    isInitialLoading: vue.Ref<boolean, boolean>;
-    isPaused: vue.Ref<boolean, boolean>;
-    isRefetching: vue.Ref<boolean, boolean>;
-    isStale: vue.Ref<boolean, boolean>;
-    isEnabled: vue.Ref<boolean, boolean>;
-    refetch: (options?: _tanstack_vue_query.RefetchOptions) => Promise<_tanstack_vue_query.QueryObserverResult<TData, Error>>;
-    fetchStatus: vue.Ref<_tanstack_vue_query.FetchStatus, _tanstack_vue_query.FetchStatus>;
-    promise: vue.Ref<Promise<TData>, Promise<TData>>;
-    suspense: () => Promise<_tanstack_vue_query.DefinedQueryObserverResult<TData, Error>>;
-    queryKey: [string, string, string, unknown, {
-        infinite: boolean;
-        optimisticUpdate: boolean;
-    }];
-};
-declare function useInternalInfiniteQuery<TQueryFnData, TData>(_schema: SchemaDef, model: string, operation: string, args: MaybeRefOrGetter<unknown>, options: MaybeRefOrGetter<Omit<UnwrapRef<UseInfiniteQueryOptions<TQueryFnData, DefaultError, InfiniteData<TData>>>, 'queryKey' | 'initialPageParam'>> | undefined): {
-    data: vue.Ref<InfiniteData<unknown, unknown>, InfiniteData<unknown, unknown>>;
-    error: vue.Ref<Error, Error>;
-    isError: vue.Ref<true, true>;
-    isPending: vue.Ref<false, false>;
-    isLoading: vue.Ref<false, false>;
-    isLoadingError: vue.Ref<false, false>;
-    isRefetchError: vue.Ref<true, true>;
-    isSuccess: vue.Ref<false, false>;
-    isPlaceholderData: vue.Ref<false, false>;
-    status: vue.Ref<"error", "error">;
-    fetchNextPage: (options?: _tanstack_vue_query.FetchNextPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    fetchPreviousPage: (options?: _tanstack_vue_query.FetchPreviousPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    hasNextPage: vue.Ref<boolean, boolean>;
-    hasPreviousPage: vue.Ref<boolean, boolean>;
-    isFetchNextPageError: vue.Ref<boolean, boolean>;
-    isFetchingNextPage: vue.Ref<boolean, boolean>;
-    isFetchPreviousPageError: vue.Ref<boolean, boolean>;
-    isFetchingPreviousPage: vue.Ref<boolean, boolean>;
-    dataUpdatedAt: vue.Ref<number, number>;
-    errorUpdatedAt: vue.Ref<number, number>;
-    failureCount: vue.Ref<number, number>;
-    failureReason: vue.Ref<Error | null, Error | null>;
-    errorUpdateCount: vue.Ref<number, number>;
-    isFetched: vue.Ref<boolean, boolean>;
-    isFetchedAfterMount: vue.Ref<boolean, boolean>;
-    isFetching: vue.Ref<boolean, boolean>;
-    isInitialLoading: vue.Ref<boolean, boolean>;
-    isPaused: vue.Ref<boolean, boolean>;
-    isRefetching: vue.Ref<boolean, boolean>;
-    isStale: vue.Ref<boolean, boolean>;
-    isEnabled: vue.Ref<boolean, boolean>;
-    refetch: (options?: _tanstack_vue_query.RefetchOptions) => Promise<_tanstack_vue_query.QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    fetchStatus: vue.Ref<_tanstack_vue_query.FetchStatus, _tanstack_vue_query.FetchStatus>;
-    promise: vue.Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
-    suspense: () => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    queryKey: [string, string, string, unknown, {
-        infinite: boolean;
-        optimisticUpdate: boolean;
-    }];
-} | {
-    data: vue.Ref<InfiniteData<unknown, unknown>, InfiniteData<unknown, unknown>>;
-    error: vue.Ref<null, null>;
-    isError: vue.Ref<false, false>;
-    isPending: vue.Ref<false, false>;
-    isLoading: vue.Ref<false, false>;
-    isLoadingError: vue.Ref<false, false>;
-    isRefetchError: vue.Ref<false, false>;
-    isFetchNextPageError: vue.Ref<false, false>;
-    isFetchPreviousPageError: vue.Ref<false, false>;
-    isSuccess: vue.Ref<true, true>;
-    isPlaceholderData: vue.Ref<false, false>;
-    status: vue.Ref<"success", "success">;
-    fetchNextPage: (options?: _tanstack_vue_query.FetchNextPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    fetchPreviousPage: (options?: _tanstack_vue_query.FetchPreviousPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    hasNextPage: vue.Ref<boolean, boolean>;
-    hasPreviousPage: vue.Ref<boolean, boolean>;
-    isFetchingNextPage: vue.Ref<boolean, boolean>;
-    isFetchingPreviousPage: vue.Ref<boolean, boolean>;
-    dataUpdatedAt: vue.Ref<number, number>;
-    errorUpdatedAt: vue.Ref<number, number>;
-    failureCount: vue.Ref<number, number>;
-    failureReason: vue.Ref<Error | null, Error | null>;
-    errorUpdateCount: vue.Ref<number, number>;
-    isFetched: vue.Ref<boolean, boolean>;
-    isFetchedAfterMount: vue.Ref<boolean, boolean>;
-    isFetching: vue.Ref<boolean, boolean>;
-    isInitialLoading: vue.Ref<boolean, boolean>;
-    isPaused: vue.Ref<boolean, boolean>;
-    isRefetching: vue.Ref<boolean, boolean>;
-    isStale: vue.Ref<boolean, boolean>;
-    isEnabled: vue.Ref<boolean, boolean>;
-    refetch: (options?: _tanstack_vue_query.RefetchOptions) => Promise<_tanstack_vue_query.QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    fetchStatus: vue.Ref<_tanstack_vue_query.FetchStatus, _tanstack_vue_query.FetchStatus>;
-    promise: vue.Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
-    suspense: () => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    queryKey: [string, string, string, unknown, {
-        infinite: boolean;
-        optimisticUpdate: boolean;
-    }];
-} | {
-    data: vue.Ref<undefined, undefined>;
-    error: vue.Ref<Error, Error>;
-    isError: vue.Ref<true, true>;
-    isPending: vue.Ref<false, false>;
-    isLoading: vue.Ref<false, false>;
-    isLoadingError: vue.Ref<true, true>;
-    isRefetchError: vue.Ref<false, false>;
-    isFetchNextPageError: vue.Ref<false, false>;
-    isFetchPreviousPageError: vue.Ref<false, false>;
-    isSuccess: vue.Ref<false, false>;
-    isPlaceholderData: vue.Ref<false, false>;
-    status: vue.Ref<"error", "error">;
-    fetchNextPage: (options?: _tanstack_vue_query.FetchNextPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    fetchPreviousPage: (options?: _tanstack_vue_query.FetchPreviousPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    hasNextPage: vue.Ref<boolean, boolean>;
-    hasPreviousPage: vue.Ref<boolean, boolean>;
-    isFetchingNextPage: vue.Ref<boolean, boolean>;
-    isFetchingPreviousPage: vue.Ref<boolean, boolean>;
-    dataUpdatedAt: vue.Ref<number, number>;
-    errorUpdatedAt: vue.Ref<number, number>;
-    failureCount: vue.Ref<number, number>;
-    failureReason: vue.Ref<Error | null, Error | null>;
-    errorUpdateCount: vue.Ref<number, number>;
-    isFetched: vue.Ref<boolean, boolean>;
-    isFetchedAfterMount: vue.Ref<boolean, boolean>;
-    isFetching: vue.Ref<boolean, boolean>;
-    isInitialLoading: vue.Ref<boolean, boolean>;
-    isPaused: vue.Ref<boolean, boolean>;
-    isRefetching: vue.Ref<boolean, boolean>;
-    isStale: vue.Ref<boolean, boolean>;
-    isEnabled: vue.Ref<boolean, boolean>;
-    refetch: (options?: _tanstack_vue_query.RefetchOptions) => Promise<_tanstack_vue_query.QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    fetchStatus: vue.Ref<_tanstack_vue_query.FetchStatus, _tanstack_vue_query.FetchStatus>;
-    promise: vue.Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
-    suspense: () => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    queryKey: [string, string, string, unknown, {
-        infinite: boolean;
-        optimisticUpdate: boolean;
-    }];
-} | {
-    data: vue.Ref<undefined, undefined>;
-    error: vue.Ref<null, null>;
-    isError: vue.Ref<false, false>;
-    isPending: vue.Ref<true, true>;
-    isLoading: vue.Ref<true, true>;
-    isLoadingError: vue.Ref<false, false>;
-    isRefetchError: vue.Ref<false, false>;
-    isFetchNextPageError: vue.Ref<false, false>;
-    isFetchPreviousPageError: vue.Ref<false, false>;
-    isSuccess: vue.Ref<false, false>;
-    isPlaceholderData: vue.Ref<false, false>;
-    status: vue.Ref<"pending", "pending">;
-    fetchNextPage: (options?: _tanstack_vue_query.FetchNextPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    fetchPreviousPage: (options?: _tanstack_vue_query.FetchPreviousPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    hasNextPage: vue.Ref<boolean, boolean>;
-    hasPreviousPage: vue.Ref<boolean, boolean>;
-    isFetchingNextPage: vue.Ref<boolean, boolean>;
-    isFetchingPreviousPage: vue.Ref<boolean, boolean>;
-    dataUpdatedAt: vue.Ref<number, number>;
-    errorUpdatedAt: vue.Ref<number, number>;
-    failureCount: vue.Ref<number, number>;
-    failureReason: vue.Ref<Error | null, Error | null>;
-    errorUpdateCount: vue.Ref<number, number>;
-    isFetched: vue.Ref<boolean, boolean>;
-    isFetchedAfterMount: vue.Ref<boolean, boolean>;
-    isFetching: vue.Ref<boolean, boolean>;
-    isInitialLoading: vue.Ref<boolean, boolean>;
-    isPaused: vue.Ref<boolean, boolean>;
-    isRefetching: vue.Ref<boolean, boolean>;
-    isStale: vue.Ref<boolean, boolean>;
-    isEnabled: vue.Ref<boolean, boolean>;
-    refetch: (options?: _tanstack_vue_query.RefetchOptions) => Promise<_tanstack_vue_query.QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    fetchStatus: vue.Ref<_tanstack_vue_query.FetchStatus, _tanstack_vue_query.FetchStatus>;
-    promise: vue.Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
-    suspense: () => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    queryKey: [string, string, string, unknown, {
-        infinite: boolean;
-        optimisticUpdate: boolean;
-    }];
-} | {
-    data: vue.Ref<undefined, undefined>;
-    error: vue.Ref<null, null>;
-    isError: vue.Ref<false, false>;
-    isPending: vue.Ref<true, true>;
-    isLoadingError: vue.Ref<false, false>;
-    isRefetchError: vue.Ref<false, false>;
-    isFetchNextPageError: vue.Ref<false, false>;
-    isFetchPreviousPageError: vue.Ref<false, false>;
-    isSuccess: vue.Ref<false, false>;
-    isPlaceholderData: vue.Ref<false, false>;
-    status: vue.Ref<"pending", "pending">;
-    fetchNextPage: (options?: _tanstack_vue_query.FetchNextPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    fetchPreviousPage: (options?: _tanstack_vue_query.FetchPreviousPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    hasNextPage: vue.Ref<boolean, boolean>;
-    hasPreviousPage: vue.Ref<boolean, boolean>;
-    isFetchingNextPage: vue.Ref<boolean, boolean>;
-    isFetchingPreviousPage: vue.Ref<boolean, boolean>;
-    dataUpdatedAt: vue.Ref<number, number>;
-    errorUpdatedAt: vue.Ref<number, number>;
-    failureCount: vue.Ref<number, number>;
-    failureReason: vue.Ref<Error | null, Error | null>;
-    errorUpdateCount: vue.Ref<number, number>;
-    isFetched: vue.Ref<boolean, boolean>;
-    isFetchedAfterMount: vue.Ref<boolean, boolean>;
-    isFetching: vue.Ref<boolean, boolean>;
-    isLoading: vue.Ref<boolean, boolean>;
-    isInitialLoading: vue.Ref<boolean, boolean>;
-    isPaused: vue.Ref<boolean, boolean>;
-    isRefetching: vue.Ref<boolean, boolean>;
-    isStale: vue.Ref<boolean, boolean>;
-    isEnabled: vue.Ref<boolean, boolean>;
-    refetch: (options?: _tanstack_vue_query.RefetchOptions) => Promise<_tanstack_vue_query.QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    fetchStatus: vue.Ref<_tanstack_vue_query.FetchStatus, _tanstack_vue_query.FetchStatus>;
-    promise: vue.Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
-    suspense: () => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    queryKey: [string, string, string, unknown, {
-        infinite: boolean;
-        optimisticUpdate: boolean;
-    }];
-} | {
-    data: vue.Ref<InfiniteData<unknown, unknown>, InfiniteData<unknown, unknown>>;
-    isError: vue.Ref<false, false>;
-    error: vue.Ref<null, null>;
-    isPending: vue.Ref<false, false>;
-    isLoading: vue.Ref<false, false>;
-    isLoadingError: vue.Ref<false, false>;
-    isRefetchError: vue.Ref<false, false>;
-    isSuccess: vue.Ref<true, true>;
-    isPlaceholderData: vue.Ref<true, true>;
-    isFetchNextPageError: vue.Ref<false, false>;
-    isFetchPreviousPageError: vue.Ref<false, false>;
-    status: vue.Ref<"success", "success">;
-    fetchNextPage: (options?: _tanstack_vue_query.FetchNextPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    fetchPreviousPage: (options?: _tanstack_vue_query.FetchPreviousPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    hasNextPage: vue.Ref<boolean, boolean>;
-    hasPreviousPage: vue.Ref<boolean, boolean>;
-    isFetchingNextPage: vue.Ref<boolean, boolean>;
-    isFetchingPreviousPage: vue.Ref<boolean, boolean>;
-    dataUpdatedAt: vue.Ref<number, number>;
-    errorUpdatedAt: vue.Ref<number, number>;
-    failureCount: vue.Ref<number, number>;
-    failureReason: vue.Ref<Error | null, Error | null>;
-    errorUpdateCount: vue.Ref<number, number>;
-    isFetched: vue.Ref<boolean, boolean>;
-    isFetchedAfterMount: vue.Ref<boolean, boolean>;
-    isFetching: vue.Ref<boolean, boolean>;
-    isInitialLoading: vue.Ref<boolean, boolean>;
-    isPaused: vue.Ref<boolean, boolean>;
-    isRefetching: vue.Ref<boolean, boolean>;
-    isStale: vue.Ref<boolean, boolean>;
-    isEnabled: vue.Ref<boolean, boolean>;
-    refetch: (options?: _tanstack_vue_query.RefetchOptions) => Promise<_tanstack_vue_query.QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    fetchStatus: vue.Ref<_tanstack_vue_query.FetchStatus, _tanstack_vue_query.FetchStatus>;
-    promise: vue.Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
-    suspense: () => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
-    queryKey: [string, string, string, unknown, {
-        infinite: boolean;
-        optimisticUpdate: boolean;
-    }];
-};
-/**
- * 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.
- */
-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<unknown, Error, void, unknown, Omit<_tanstack_vue_query.MutationObserverIdleResult<unknown, Error, void, unknown>, "mutate" | "reset"> | Omit<_tanstack_vue_query.MutationObserverLoadingResult<unknown, Error, void, unknown>, "mutate" | "reset"> | Omit<_tanstack_vue_query.MutationObserverErrorResult<unknown, Error, void, unknown>, "mutate" | "reset"> | Omit<_tanstack_vue_query.MutationObserverSuccessResult<unknown, Error, void, unknown>, "mutate" | "reset">>;
-
-export { type ClientHooks, type ModelInfiniteQueryOptions, type ModelInfiniteQueryResult, type ModelMutationModelResult, type ModelMutationOptions, type ModelMutationResult, type ModelQueryHooks, type ModelQueryOptions, type ModelQueryResult, VueQueryContextKey, provideHooksContext, provideQuerySettingsContext, useClientQueries, useInternalInfiniteQuery, useInternalMutation, useInternalQuery, useModelQueries };

package/eslint.config.js

@@ -1,4 +0,0 @@
-import config from '@zenstackhq/eslint-config/base.js';
-
-/** @type {import("eslint").Linter.Config} */
-export default config;