@zenstackhq/tanstack-query 3.0.0 → 3.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (56) hide show
  1. package/dist/common/client.d.ts +4 -0
  2. package/dist/common/client.js +38 -0
  3. package/dist/common/client.js.map +1 -0
  4. package/dist/common/query-key.d.ts +39 -0
  5. package/dist/common/query-key.js +38 -0
  6. package/dist/common/query-key.js.map +1 -0
  7. package/dist/common/types.d.ts +60 -0
  8. package/dist/common/types.js +2 -0
  9. package/dist/common/types.js.map +1 -0
  10. package/dist/react.d.ts +99 -150
  11. package/dist/react.js +248 -1178
  12. package/dist/react.js.map +1 -1
  13. package/dist/svelte/index.svelte.d.ts +79 -0
  14. package/dist/svelte/index.svelte.js +245 -0
  15. package/dist/vue.d.ts +313 -342
  16. package/dist/vue.js +224 -1138
  17. package/dist/vue.js.map +1 -1
  18. package/package.json +36 -48
  19. package/.turbo/turbo-build.log +0 -47
  20. package/dist/react.cjs +0 -1240
  21. package/dist/react.cjs.map +0 -1
  22. package/dist/react.d.cts +0 -616
  23. package/dist/svelte.cjs +0 -1224
  24. package/dist/svelte.cjs.map +0 -1
  25. package/dist/svelte.d.cts +0 -381
  26. package/dist/svelte.d.ts +0 -381
  27. package/dist/svelte.js +0 -1183
  28. package/dist/svelte.js.map +0 -1
  29. package/dist/types-C8iIZD-7.d.cts +0 -99
  30. package/dist/types-C8iIZD-7.d.ts +0 -99
  31. package/dist/vue.cjs +0 -1192
  32. package/dist/vue.cjs.map +0 -1
  33. package/dist/vue.d.cts +0 -382
  34. package/eslint.config.js +0 -4
  35. package/src/react.ts +0 -562
  36. package/src/svelte.ts +0 -502
  37. package/src/utils/common.ts +0 -448
  38. package/src/utils/mutator.ts +0 -441
  39. package/src/utils/nested-read-visitor.ts +0 -61
  40. package/src/utils/nested-write-visitor.ts +0 -359
  41. package/src/utils/query-analysis.ts +0 -116
  42. package/src/utils/serialization.ts +0 -39
  43. package/src/utils/types.ts +0 -43
  44. package/src/vue.ts +0 -448
  45. package/test/react-query.test.tsx +0 -1787
  46. package/test/react-typing-test.ts +0 -113
  47. package/test/schemas/basic/input.ts +0 -110
  48. package/test/schemas/basic/models.ts +0 -14
  49. package/test/schemas/basic/schema-lite.ts +0 -172
  50. package/test/schemas/basic/schema.zmodel +0 -35
  51. package/test/svelte-typing-test.ts +0 -111
  52. package/test/vue-typing-test.ts +0 -111
  53. package/tsconfig.json +0 -7
  54. package/tsconfig.test.json +0 -8
  55. package/tsup.config.ts +0 -15
  56. package/vitest.config.ts +0 -11
package/dist/vue.d.ts CHANGED
@@ -1,370 +1,343 @@
1
- import * as _tanstack_vue_query from '@tanstack/vue-query';
2
- import { UseQueryOptions, DefaultError, UseQueryReturnType, QueryKey, UseInfiniteQueryOptions, InfiniteData, UseInfiniteQueryReturnType, UseMutationOptions, UseMutationReturnType } from '@tanstack/vue-query';
3
- import * as vue from 'vue';
4
- import { MaybeRefOrGetter, UnwrapRef } from 'vue';
5
- 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';
6
- import { SchemaDef, GetModels } from '@zenstackhq/schema';
7
- import { A as APIContext, E as ExtraQueryOptions, W as WithOptimistic, a as ExtraMutationOptions, T as TrimDelegateModelOperations } from './types-C8iIZD-7.js';
8
- export { F as FetchFn } from './types-C8iIZD-7.js';
9
-
10
- declare const VueQueryContextKey = "zenstack-vue-query-context";
1
+ import { type DefaultError, type InfiniteData, type QueryKey, type UseInfiniteQueryOptions, type UseInfiniteQueryReturnType, type UseMutationOptions, type UseMutationReturnType, type UseQueryOptions, type UseQueryReturnType } from '@tanstack/vue-query';
2
+ import type { AggregateArgs, AggregateResult, BatchResult, CountArgs, CountResult, CreateArgs, CreateManyAndReturnArgs, CreateManyArgs, DeleteArgs, DeleteManyArgs, FindFirstArgs, FindManyArgs, FindUniqueArgs, GroupByArgs, GroupByResult, QueryOptions, SelectSubset, SimplifiedPlainResult, SimplifiedResult, Subset, UpdateArgs, UpdateManyAndReturnArgs, UpdateManyArgs, UpsertArgs } from '@zenstackhq/orm';
3
+ import type { GetModels, SchemaDef } from '@zenstackhq/schema';
4
+ import { type MaybeRefOrGetter, type Ref, type UnwrapRef } from 'vue';
5
+ import type { ExtraMutationOptions, ExtraQueryOptions, QueryContext, TrimDelegateModelOperations, WithOptimistic } from './common/types';
6
+ export type { FetchFn } from '@zenstackhq/client-helpers/fetch';
7
+ export declare const VueQueryContextKey = "zenstack-vue-query-context";
11
8
  /**
12
9
  * Provide context for query settings.
13
10
  *
14
11
  * @deprecated Use {@link provideQuerySettingsContext} instead.
15
12
  */
16
- declare function provideHooksContext(context: APIContext): void;
13
+ export declare function provideHooksContext(context: QueryContext): void;
17
14
  /**
18
15
  * Provide context for query settings.
19
16
  */
20
- declare function provideQuerySettingsContext(context: APIContext): void;
21
- type ModelQueryOptions<T> = MaybeRefOrGetter<Omit<UnwrapRef<UseQueryOptions<T, DefaultError>>, 'queryKey'> & ExtraQueryOptions>;
22
- type ModelQueryResult<T> = UseQueryReturnType<WithOptimistic<T>, DefaultError> & {
23
- queryKey: QueryKey;
17
+ export declare function provideQuerySettingsContext(context: QueryContext): void;
18
+ export type ModelQueryOptions<T> = MaybeRefOrGetter<Omit<UnwrapRef<UseQueryOptions<T, DefaultError>>, 'queryKey'> & ExtraQueryOptions>;
19
+ export type ModelQueryResult<T> = UseQueryReturnType<WithOptimistic<T>, DefaultError> & {
20
+ queryKey: Ref<QueryKey>;
24
21
  };
25
- type ModelInfiniteQueryOptions<T> = MaybeRefOrGetter<Omit<UnwrapRef<UseInfiniteQueryOptions<T, DefaultError, InfiniteData<T>>>, 'queryKey' | 'initialPageParam'>>;
26
- type ModelInfiniteQueryResult<T> = UseInfiniteQueryReturnType<T, DefaultError> & {
27
- queryKey: QueryKey;
22
+ export type ModelInfiniteQueryOptions<T> = MaybeRefOrGetter<Omit<UnwrapRef<UseInfiniteQueryOptions<T, DefaultError, InfiniteData<T>>>, 'queryKey' | 'initialPageParam'> & QueryContext>;
23
+ export type ModelInfiniteQueryResult<T> = UseInfiniteQueryReturnType<T, DefaultError> & {
24
+ queryKey: Ref<QueryKey>;
28
25
  };
29
- type ModelMutationOptions<T, TArgs> = MaybeRefOrGetter<Omit<UnwrapRef<UseMutationOptions<T, DefaultError, TArgs>>, 'mutationFn'> & ExtraMutationOptions>;
30
- type ModelMutationResult<T, TArgs> = UseMutationReturnType<T, DefaultError, TArgs, unknown>;
31
- 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'> & {
26
+ export type ModelMutationOptions<T, TArgs> = MaybeRefOrGetter<Omit<UnwrapRef<UseMutationOptions<T, DefaultError, TArgs>>, 'mutationFn'> & ExtraMutationOptions>;
27
+ export type ModelMutationResult<T, TArgs> = UseMutationReturnType<T, DefaultError, TArgs, unknown>;
28
+ export 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'> & {
32
29
  mutateAsync<T extends TArgs>(args: T, options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array>, T>): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array>>;
33
30
  };
34
- type ClientHooks<Schema extends SchemaDef, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = {
31
+ export type ClientHooks<Schema extends SchemaDef, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = {
35
32
  [Model in GetModels<Schema> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options>;
36
33
  };
37
- type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = TrimDelegateModelOperations<Schema, Model, {
38
- 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>;
39
- 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>;
40
- 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>[]>;
41
- 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>[]>>;
42
- useCreate<T extends CreateArgs<Schema, Model>>(options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>): ModelMutationModelResult<Schema, Model, T, false, Options>;
43
- useCreateMany<T extends CreateManyArgs<Schema, Model>>(options?: ModelMutationOptions<BatchResult, T>): ModelMutationResult<BatchResult, T>;
44
- useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>[], T>): ModelMutationModelResult<Schema, Model, T, true, Options>;
45
- useUpdate<T extends UpdateArgs<Schema, Model>>(options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>): ModelMutationModelResult<Schema, Model, T, false, Options>;
46
- useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(options?: ModelMutationOptions<BatchResult, T>): ModelMutationResult<BatchResult, T>;
47
- useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>[], T>): ModelMutationModelResult<Schema, Model, T, true, Options>;
48
- useUpsert<T extends UpsertArgs<Schema, Model>>(options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>): ModelMutationModelResult<Schema, Model, T, false, Options>;
49
- useDelete<T extends DeleteArgs<Schema, Model>>(options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>): ModelMutationModelResult<Schema, Model, T, false, Options>;
50
- useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(options?: ModelMutationOptions<BatchResult, T>): ModelMutationResult<BatchResult, T>;
51
- useCount<T extends CountArgs<Schema, Model>>(args?: Subset<T, CountArgs<Schema, Model>>, options?: ModelQueryOptions<CountResult<Schema, Model, T>>): ModelQueryResult<CountResult<Schema, Model, T>>;
52
- useAggregate<T extends AggregateArgs<Schema, Model>>(args: Subset<T, AggregateArgs<Schema, Model>>, options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>): ModelQueryResult<AggregateResult<Schema, Model, T>>;
53
- useGroupBy<T extends GroupByArgs<Schema, Model>>(args: Subset<T, GroupByArgs<Schema, Model>>, options?: ModelQueryOptions<GroupByResult<Schema, Model, T>>): ModelQueryResult<GroupByResult<Schema, Model, T>>;
34
+ export type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = TrimDelegateModelOperations<Schema, Model, {
35
+ useFindUnique<T extends FindUniqueArgs<Schema, Model>>(args: MaybeRefOrGetter<SelectSubset<T, FindUniqueArgs<Schema, Model>>>, options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options> | null>>): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options> | null>;
36
+ useFindFirst<T extends FindFirstArgs<Schema, Model>>(args?: MaybeRefOrGetter<SelectSubset<T, FindFirstArgs<Schema, Model>>>, options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options> | null>>): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options> | null>;
37
+ useFindMany<T extends FindManyArgs<Schema, Model>>(args?: MaybeRefOrGetter<SelectSubset<T, FindManyArgs<Schema, Model>>>, options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options>[]>>): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options>[]>;
38
+ useInfiniteFindMany<T extends FindManyArgs<Schema, Model>>(args?: MaybeRefOrGetter<SelectSubset<T, FindManyArgs<Schema, Model>>>, options?: MaybeRefOrGetter<ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options>[]>>): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options>[]>>;
39
+ useCreate<T extends CreateArgs<Schema, Model>>(options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>>): ModelMutationModelResult<Schema, Model, T, false, Options>;
40
+ useCreateMany<T extends CreateManyArgs<Schema, Model>>(options?: MaybeRefOrGetter<ModelMutationOptions<BatchResult, T>>): ModelMutationResult<BatchResult, T>;
41
+ useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>[], T>>): ModelMutationModelResult<Schema, Model, T, true, Options>;
42
+ useUpdate<T extends UpdateArgs<Schema, Model>>(options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>>): ModelMutationModelResult<Schema, Model, T, false, Options>;
43
+ useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(options?: MaybeRefOrGetter<ModelMutationOptions<BatchResult, T>>): ModelMutationResult<BatchResult, T>;
44
+ useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>[], T>>): ModelMutationModelResult<Schema, Model, T, true, Options>;
45
+ useUpsert<T extends UpsertArgs<Schema, Model>>(options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>>): ModelMutationModelResult<Schema, Model, T, false, Options>;
46
+ useDelete<T extends DeleteArgs<Schema, Model>>(options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>>): ModelMutationModelResult<Schema, Model, T, false, Options>;
47
+ useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(options?: MaybeRefOrGetter<ModelMutationOptions<BatchResult, T>>): ModelMutationResult<BatchResult, T>;
48
+ useCount<T extends CountArgs<Schema, Model>>(args?: MaybeRefOrGetter<Subset<T, CountArgs<Schema, Model>>>, options?: MaybeRefOrGetter<ModelQueryOptions<CountResult<Schema, Model, T>>>): ModelQueryResult<CountResult<Schema, Model, T>>;
49
+ useAggregate<T extends AggregateArgs<Schema, Model>>(args: MaybeRefOrGetter<Subset<T, AggregateArgs<Schema, Model>>>, options?: MaybeRefOrGetter<ModelQueryOptions<AggregateResult<Schema, Model, T>>>): ModelQueryResult<AggregateResult<Schema, Model, T>>;
50
+ useGroupBy<T extends GroupByArgs<Schema, Model>>(args: MaybeRefOrGetter<Subset<T, GroupByArgs<Schema, Model>>>, options?: MaybeRefOrGetter<ModelQueryOptions<GroupByResult<Schema, Model, T>>>): ModelQueryResult<GroupByResult<Schema, Model, T>>;
54
51
  }>;
55
52
  /**
56
53
  * Gets data query hooks for all models in the schema.
57
54
  */
58
- declare function useClientQueries<Schema extends SchemaDef, Options extends QueryOptions<Schema> = QueryOptions<Schema>>(schema: Schema): ClientHooks<Schema, Options>;
55
+ export declare function useClientQueries<Schema extends SchemaDef, Options extends QueryOptions<Schema> = QueryOptions<Schema>>(schema: Schema, options?: MaybeRefOrGetter<QueryContext>): ClientHooks<Schema, Options>;
59
56
  /**
60
57
  * Gets data query hooks for a specific model in the schema.
61
58
  */
62
- declare function useModelQueries<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>>(schema: Schema, model: Model): ModelQueryHooks<Schema, Model, Options>;
63
- declare function useInternalQuery<TQueryFnData, TData>(_schema: SchemaDef, model: string, operation: string, args?: MaybeRefOrGetter<unknown>, options?: MaybeRefOrGetter<Omit<UnwrapRef<UseQueryOptions<TQueryFnData, DefaultError, TData>>, 'queryKey'> & ExtraQueryOptions>): {
64
- data: vue.Ref<TData, TData>;
65
- error: vue.Ref<Error, Error>;
66
- isError: vue.Ref<true, true>;
67
- isPending: vue.Ref<false, false>;
68
- isLoading: vue.Ref<false, false>;
69
- isLoadingError: vue.Ref<false, false>;
70
- isRefetchError: vue.Ref<true, true>;
71
- isSuccess: vue.Ref<false, false>;
72
- isPlaceholderData: vue.Ref<false, false>;
73
- status: vue.Ref<"error", "error">;
74
- dataUpdatedAt: vue.Ref<number, number>;
75
- errorUpdatedAt: vue.Ref<number, number>;
76
- failureCount: vue.Ref<number, number>;
77
- failureReason: vue.Ref<Error | null, Error | null>;
78
- errorUpdateCount: vue.Ref<number, number>;
79
- isFetched: vue.Ref<boolean, boolean>;
80
- isFetchedAfterMount: vue.Ref<boolean, boolean>;
81
- isFetching: vue.Ref<boolean, boolean>;
82
- isInitialLoading: vue.Ref<boolean, boolean>;
83
- isPaused: vue.Ref<boolean, boolean>;
84
- isRefetching: vue.Ref<boolean, boolean>;
85
- isStale: vue.Ref<boolean, boolean>;
86
- isEnabled: vue.Ref<boolean, boolean>;
87
- refetch: (options?: _tanstack_vue_query.RefetchOptions) => Promise<_tanstack_vue_query.QueryObserverResult<TData, Error>>;
88
- fetchStatus: vue.Ref<_tanstack_vue_query.FetchStatus, _tanstack_vue_query.FetchStatus>;
89
- promise: vue.Ref<Promise<TData>, Promise<TData>>;
90
- suspense: () => Promise<_tanstack_vue_query.DefinedQueryObserverResult<TData, Error>>;
91
- queryKey: [string, string, string, unknown, {
92
- infinite: boolean;
93
- optimisticUpdate: boolean;
94
- }];
59
+ export declare function useModelQueries<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>>(schema: Schema, model: Model, rootOptions?: MaybeRefOrGetter<QueryContext>): ModelQueryHooks<Schema, Model, Options>;
60
+ export declare function useInternalQuery<TQueryFnData, TData>(_schema: SchemaDef, model: string, operation: string, args?: MaybeRefOrGetter<unknown>, options?: MaybeRefOrGetter<Omit<UnwrapRef<UseQueryOptions<TQueryFnData, DefaultError, TData>>, 'queryKey'> & ExtraQueryOptions>): {
61
+ data: Ref<TData, TData>;
62
+ error: Ref<Error, Error>;
63
+ isError: Ref<true, true>;
64
+ isPending: Ref<false, false>;
65
+ isLoading: Ref<false, false>;
66
+ isLoadingError: Ref<false, false>;
67
+ isRefetchError: Ref<true, true>;
68
+ isSuccess: Ref<false, false>;
69
+ isPlaceholderData: Ref<false, false>;
70
+ status: Ref<"error", "error">;
71
+ dataUpdatedAt: Ref<number, number>;
72
+ errorUpdatedAt: Ref<number, number>;
73
+ failureCount: Ref<number, number>;
74
+ failureReason: Ref<Error | null, Error | null>;
75
+ errorUpdateCount: Ref<number, number>;
76
+ isFetched: Ref<boolean, boolean>;
77
+ isFetchedAfterMount: Ref<boolean, boolean>;
78
+ isFetching: Ref<boolean, boolean>;
79
+ isInitialLoading: Ref<boolean, boolean>;
80
+ isPaused: Ref<boolean, boolean>;
81
+ isRefetching: Ref<boolean, boolean>;
82
+ isStale: Ref<boolean, boolean>;
83
+ isEnabled: Ref<boolean, boolean>;
84
+ refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TData, Error>>;
85
+ fetchStatus: Ref<import("@tanstack/query-core").FetchStatus, import("@tanstack/query-core").FetchStatus>;
86
+ promise: Ref<Promise<TData>, Promise<TData>>;
87
+ suspense: () => Promise<import("@tanstack/query-core").DefinedQueryObserverResult<TData, Error>>;
88
+ queryKey: import("vue").ComputedRef<import("./common/query-key").QueryKey>;
95
89
  } | {
96
- data: vue.Ref<TData, TData>;
97
- error: vue.Ref<null, null>;
98
- isError: vue.Ref<false, false>;
99
- isPending: vue.Ref<false, false>;
100
- isLoading: vue.Ref<false, false>;
101
- isLoadingError: vue.Ref<false, false>;
102
- isRefetchError: vue.Ref<false, false>;
103
- isSuccess: vue.Ref<true, true>;
104
- isPlaceholderData: vue.Ref<false, false>;
105
- status: vue.Ref<"success", "success">;
106
- dataUpdatedAt: vue.Ref<number, number>;
107
- errorUpdatedAt: vue.Ref<number, number>;
108
- failureCount: vue.Ref<number, number>;
109
- failureReason: vue.Ref<Error | null, Error | null>;
110
- errorUpdateCount: vue.Ref<number, number>;
111
- isFetched: vue.Ref<boolean, boolean>;
112
- isFetchedAfterMount: vue.Ref<boolean, boolean>;
113
- isFetching: vue.Ref<boolean, boolean>;
114
- isInitialLoading: vue.Ref<boolean, boolean>;
115
- isPaused: vue.Ref<boolean, boolean>;
116
- isRefetching: vue.Ref<boolean, boolean>;
117
- isStale: vue.Ref<boolean, boolean>;
118
- isEnabled: vue.Ref<boolean, boolean>;
119
- refetch: (options?: _tanstack_vue_query.RefetchOptions) => Promise<_tanstack_vue_query.QueryObserverResult<TData, Error>>;
120
- fetchStatus: vue.Ref<_tanstack_vue_query.FetchStatus, _tanstack_vue_query.FetchStatus>;
121
- promise: vue.Ref<Promise<TData>, Promise<TData>>;
122
- suspense: () => Promise<_tanstack_vue_query.DefinedQueryObserverResult<TData, Error>>;
123
- queryKey: [string, string, string, unknown, {
124
- infinite: boolean;
125
- optimisticUpdate: boolean;
126
- }];
90
+ data: Ref<TData, TData>;
91
+ error: Ref<null, null>;
92
+ isError: Ref<false, false>;
93
+ isPending: Ref<false, false>;
94
+ isLoading: Ref<false, false>;
95
+ isLoadingError: Ref<false, false>;
96
+ isRefetchError: Ref<false, false>;
97
+ isSuccess: Ref<true, true>;
98
+ isPlaceholderData: Ref<false, false>;
99
+ status: Ref<"success", "success">;
100
+ dataUpdatedAt: Ref<number, number>;
101
+ errorUpdatedAt: Ref<number, number>;
102
+ failureCount: Ref<number, number>;
103
+ failureReason: Ref<Error | null, Error | null>;
104
+ errorUpdateCount: Ref<number, number>;
105
+ isFetched: Ref<boolean, boolean>;
106
+ isFetchedAfterMount: Ref<boolean, boolean>;
107
+ isFetching: Ref<boolean, boolean>;
108
+ isInitialLoading: Ref<boolean, boolean>;
109
+ isPaused: Ref<boolean, boolean>;
110
+ isRefetching: Ref<boolean, boolean>;
111
+ isStale: Ref<boolean, boolean>;
112
+ isEnabled: Ref<boolean, boolean>;
113
+ refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TData, Error>>;
114
+ fetchStatus: Ref<import("@tanstack/query-core").FetchStatus, import("@tanstack/query-core").FetchStatus>;
115
+ promise: Ref<Promise<TData>, Promise<TData>>;
116
+ suspense: () => Promise<import("@tanstack/query-core").DefinedQueryObserverResult<TData, Error>>;
117
+ queryKey: import("vue").ComputedRef<import("./common/query-key").QueryKey>;
127
118
  };
128
- 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): {
129
- data: vue.Ref<InfiniteData<unknown, unknown>, InfiniteData<unknown, unknown>>;
130
- error: vue.Ref<Error, Error>;
131
- isError: vue.Ref<true, true>;
132
- isPending: vue.Ref<false, false>;
133
- isLoading: vue.Ref<false, false>;
134
- isLoadingError: vue.Ref<false, false>;
135
- isRefetchError: vue.Ref<true, true>;
136
- isSuccess: vue.Ref<false, false>;
137
- isPlaceholderData: vue.Ref<false, false>;
138
- status: vue.Ref<"error", "error">;
139
- fetchNextPage: (options?: _tanstack_vue_query.FetchNextPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
140
- fetchPreviousPage: (options?: _tanstack_vue_query.FetchPreviousPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
141
- hasNextPage: vue.Ref<boolean, boolean>;
142
- hasPreviousPage: vue.Ref<boolean, boolean>;
143
- isFetchNextPageError: vue.Ref<boolean, boolean>;
144
- isFetchingNextPage: vue.Ref<boolean, boolean>;
145
- isFetchPreviousPageError: vue.Ref<boolean, boolean>;
146
- isFetchingPreviousPage: vue.Ref<boolean, boolean>;
147
- dataUpdatedAt: vue.Ref<number, number>;
148
- errorUpdatedAt: vue.Ref<number, number>;
149
- failureCount: vue.Ref<number, number>;
150
- failureReason: vue.Ref<Error | null, Error | null>;
151
- errorUpdateCount: vue.Ref<number, number>;
152
- isFetched: vue.Ref<boolean, boolean>;
153
- isFetchedAfterMount: vue.Ref<boolean, boolean>;
154
- isFetching: vue.Ref<boolean, boolean>;
155
- isInitialLoading: vue.Ref<boolean, boolean>;
156
- isPaused: vue.Ref<boolean, boolean>;
157
- isRefetching: vue.Ref<boolean, boolean>;
158
- isStale: vue.Ref<boolean, boolean>;
159
- isEnabled: vue.Ref<boolean, boolean>;
160
- refetch: (options?: _tanstack_vue_query.RefetchOptions) => Promise<_tanstack_vue_query.QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
161
- fetchStatus: vue.Ref<_tanstack_vue_query.FetchStatus, _tanstack_vue_query.FetchStatus>;
162
- promise: vue.Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
163
- suspense: () => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
164
- queryKey: [string, string, string, unknown, {
165
- infinite: boolean;
166
- optimisticUpdate: boolean;
167
- }];
119
+ export 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'> & QueryContext) | undefined>): {
120
+ data: Ref<InfiniteData<unknown, unknown>, InfiniteData<unknown, unknown>>;
121
+ error: Ref<Error, Error>;
122
+ isError: Ref<true, true>;
123
+ isPending: Ref<false, false>;
124
+ isLoading: Ref<false, false>;
125
+ isLoadingError: Ref<false, false>;
126
+ isRefetchError: Ref<true, true>;
127
+ isSuccess: Ref<false, false>;
128
+ isPlaceholderData: Ref<false, false>;
129
+ status: Ref<"error", "error">;
130
+ fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
131
+ fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
132
+ hasNextPage: Ref<boolean, boolean>;
133
+ hasPreviousPage: Ref<boolean, boolean>;
134
+ isFetchNextPageError: Ref<boolean, boolean>;
135
+ isFetchingNextPage: Ref<boolean, boolean>;
136
+ isFetchPreviousPageError: Ref<boolean, boolean>;
137
+ isFetchingPreviousPage: Ref<boolean, boolean>;
138
+ dataUpdatedAt: Ref<number, number>;
139
+ errorUpdatedAt: Ref<number, number>;
140
+ failureCount: Ref<number, number>;
141
+ failureReason: Ref<Error | null, Error | null>;
142
+ errorUpdateCount: Ref<number, number>;
143
+ isFetched: Ref<boolean, boolean>;
144
+ isFetchedAfterMount: Ref<boolean, boolean>;
145
+ isFetching: Ref<boolean, boolean>;
146
+ isInitialLoading: Ref<boolean, boolean>;
147
+ isPaused: Ref<boolean, boolean>;
148
+ isRefetching: Ref<boolean, boolean>;
149
+ isStale: Ref<boolean, boolean>;
150
+ isEnabled: Ref<boolean, boolean>;
151
+ refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
152
+ fetchStatus: Ref<import("@tanstack/query-core").FetchStatus, import("@tanstack/query-core").FetchStatus>;
153
+ promise: Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
154
+ suspense: () => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
155
+ queryKey: import("vue").ComputedRef<import("./common/query-key").QueryKey>;
168
156
  } | {
169
- data: vue.Ref<InfiniteData<unknown, unknown>, InfiniteData<unknown, unknown>>;
170
- error: vue.Ref<null, null>;
171
- isError: vue.Ref<false, false>;
172
- isPending: vue.Ref<false, false>;
173
- isLoading: vue.Ref<false, false>;
174
- isLoadingError: vue.Ref<false, false>;
175
- isRefetchError: vue.Ref<false, false>;
176
- isFetchNextPageError: vue.Ref<false, false>;
177
- isFetchPreviousPageError: vue.Ref<false, false>;
178
- isSuccess: vue.Ref<true, true>;
179
- isPlaceholderData: vue.Ref<false, false>;
180
- status: vue.Ref<"success", "success">;
181
- fetchNextPage: (options?: _tanstack_vue_query.FetchNextPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
182
- fetchPreviousPage: (options?: _tanstack_vue_query.FetchPreviousPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
183
- hasNextPage: vue.Ref<boolean, boolean>;
184
- hasPreviousPage: vue.Ref<boolean, boolean>;
185
- isFetchingNextPage: vue.Ref<boolean, boolean>;
186
- isFetchingPreviousPage: vue.Ref<boolean, boolean>;
187
- dataUpdatedAt: vue.Ref<number, number>;
188
- errorUpdatedAt: vue.Ref<number, number>;
189
- failureCount: vue.Ref<number, number>;
190
- failureReason: vue.Ref<Error | null, Error | null>;
191
- errorUpdateCount: vue.Ref<number, number>;
192
- isFetched: vue.Ref<boolean, boolean>;
193
- isFetchedAfterMount: vue.Ref<boolean, boolean>;
194
- isFetching: vue.Ref<boolean, boolean>;
195
- isInitialLoading: vue.Ref<boolean, boolean>;
196
- isPaused: vue.Ref<boolean, boolean>;
197
- isRefetching: vue.Ref<boolean, boolean>;
198
- isStale: vue.Ref<boolean, boolean>;
199
- isEnabled: vue.Ref<boolean, boolean>;
200
- refetch: (options?: _tanstack_vue_query.RefetchOptions) => Promise<_tanstack_vue_query.QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
201
- fetchStatus: vue.Ref<_tanstack_vue_query.FetchStatus, _tanstack_vue_query.FetchStatus>;
202
- promise: vue.Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
203
- suspense: () => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
204
- queryKey: [string, string, string, unknown, {
205
- infinite: boolean;
206
- optimisticUpdate: boolean;
207
- }];
157
+ data: Ref<InfiniteData<unknown, unknown>, InfiniteData<unknown, unknown>>;
158
+ error: Ref<null, null>;
159
+ isError: Ref<false, false>;
160
+ isPending: Ref<false, false>;
161
+ isLoading: Ref<false, false>;
162
+ isLoadingError: Ref<false, false>;
163
+ isRefetchError: Ref<false, false>;
164
+ isFetchNextPageError: Ref<false, false>;
165
+ isFetchPreviousPageError: Ref<false, false>;
166
+ isSuccess: Ref<true, true>;
167
+ isPlaceholderData: Ref<false, false>;
168
+ status: Ref<"success", "success">;
169
+ fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
170
+ fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
171
+ hasNextPage: Ref<boolean, boolean>;
172
+ hasPreviousPage: Ref<boolean, boolean>;
173
+ isFetchingNextPage: Ref<boolean, boolean>;
174
+ isFetchingPreviousPage: Ref<boolean, boolean>;
175
+ dataUpdatedAt: Ref<number, number>;
176
+ errorUpdatedAt: Ref<number, number>;
177
+ failureCount: Ref<number, number>;
178
+ failureReason: Ref<Error | null, Error | null>;
179
+ errorUpdateCount: Ref<number, number>;
180
+ isFetched: Ref<boolean, boolean>;
181
+ isFetchedAfterMount: Ref<boolean, boolean>;
182
+ isFetching: Ref<boolean, boolean>;
183
+ isInitialLoading: Ref<boolean, boolean>;
184
+ isPaused: Ref<boolean, boolean>;
185
+ isRefetching: Ref<boolean, boolean>;
186
+ isStale: Ref<boolean, boolean>;
187
+ isEnabled: Ref<boolean, boolean>;
188
+ refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
189
+ fetchStatus: Ref<import("@tanstack/query-core").FetchStatus, import("@tanstack/query-core").FetchStatus>;
190
+ promise: Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
191
+ suspense: () => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
192
+ queryKey: import("vue").ComputedRef<import("./common/query-key").QueryKey>;
208
193
  } | {
209
- data: vue.Ref<undefined, undefined>;
210
- error: vue.Ref<Error, Error>;
211
- isError: vue.Ref<true, true>;
212
- isPending: vue.Ref<false, false>;
213
- isLoading: vue.Ref<false, false>;
214
- isLoadingError: vue.Ref<true, true>;
215
- isRefetchError: vue.Ref<false, false>;
216
- isFetchNextPageError: vue.Ref<false, false>;
217
- isFetchPreviousPageError: vue.Ref<false, false>;
218
- isSuccess: vue.Ref<false, false>;
219
- isPlaceholderData: vue.Ref<false, false>;
220
- status: vue.Ref<"error", "error">;
221
- fetchNextPage: (options?: _tanstack_vue_query.FetchNextPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
222
- fetchPreviousPage: (options?: _tanstack_vue_query.FetchPreviousPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
223
- hasNextPage: vue.Ref<boolean, boolean>;
224
- hasPreviousPage: vue.Ref<boolean, boolean>;
225
- isFetchingNextPage: vue.Ref<boolean, boolean>;
226
- isFetchingPreviousPage: vue.Ref<boolean, boolean>;
227
- dataUpdatedAt: vue.Ref<number, number>;
228
- errorUpdatedAt: vue.Ref<number, number>;
229
- failureCount: vue.Ref<number, number>;
230
- failureReason: vue.Ref<Error | null, Error | null>;
231
- errorUpdateCount: vue.Ref<number, number>;
232
- isFetched: vue.Ref<boolean, boolean>;
233
- isFetchedAfterMount: vue.Ref<boolean, boolean>;
234
- isFetching: vue.Ref<boolean, boolean>;
235
- isInitialLoading: vue.Ref<boolean, boolean>;
236
- isPaused: vue.Ref<boolean, boolean>;
237
- isRefetching: vue.Ref<boolean, boolean>;
238
- isStale: vue.Ref<boolean, boolean>;
239
- isEnabled: vue.Ref<boolean, boolean>;
240
- refetch: (options?: _tanstack_vue_query.RefetchOptions) => Promise<_tanstack_vue_query.QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
241
- fetchStatus: vue.Ref<_tanstack_vue_query.FetchStatus, _tanstack_vue_query.FetchStatus>;
242
- promise: vue.Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
243
- suspense: () => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
244
- queryKey: [string, string, string, unknown, {
245
- infinite: boolean;
246
- optimisticUpdate: boolean;
247
- }];
194
+ data: Ref<undefined, undefined>;
195
+ error: Ref<Error, Error>;
196
+ isError: Ref<true, true>;
197
+ isPending: Ref<false, false>;
198
+ isLoading: Ref<false, false>;
199
+ isLoadingError: Ref<true, true>;
200
+ isRefetchError: Ref<false, false>;
201
+ isFetchNextPageError: Ref<false, false>;
202
+ isFetchPreviousPageError: Ref<false, false>;
203
+ isSuccess: Ref<false, false>;
204
+ isPlaceholderData: Ref<false, false>;
205
+ status: Ref<"error", "error">;
206
+ fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
207
+ fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
208
+ hasNextPage: Ref<boolean, boolean>;
209
+ hasPreviousPage: Ref<boolean, boolean>;
210
+ isFetchingNextPage: Ref<boolean, boolean>;
211
+ isFetchingPreviousPage: Ref<boolean, boolean>;
212
+ dataUpdatedAt: Ref<number, number>;
213
+ errorUpdatedAt: Ref<number, number>;
214
+ failureCount: Ref<number, number>;
215
+ failureReason: Ref<Error | null, Error | null>;
216
+ errorUpdateCount: Ref<number, number>;
217
+ isFetched: Ref<boolean, boolean>;
218
+ isFetchedAfterMount: Ref<boolean, boolean>;
219
+ isFetching: Ref<boolean, boolean>;
220
+ isInitialLoading: Ref<boolean, boolean>;
221
+ isPaused: Ref<boolean, boolean>;
222
+ isRefetching: Ref<boolean, boolean>;
223
+ isStale: Ref<boolean, boolean>;
224
+ isEnabled: Ref<boolean, boolean>;
225
+ refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
226
+ fetchStatus: Ref<import("@tanstack/query-core").FetchStatus, import("@tanstack/query-core").FetchStatus>;
227
+ promise: Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
228
+ suspense: () => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
229
+ queryKey: import("vue").ComputedRef<import("./common/query-key").QueryKey>;
248
230
  } | {
249
- data: vue.Ref<undefined, undefined>;
250
- error: vue.Ref<null, null>;
251
- isError: vue.Ref<false, false>;
252
- isPending: vue.Ref<true, true>;
253
- isLoading: vue.Ref<true, true>;
254
- isLoadingError: vue.Ref<false, false>;
255
- isRefetchError: vue.Ref<false, false>;
256
- isFetchNextPageError: vue.Ref<false, false>;
257
- isFetchPreviousPageError: vue.Ref<false, false>;
258
- isSuccess: vue.Ref<false, false>;
259
- isPlaceholderData: vue.Ref<false, false>;
260
- status: vue.Ref<"pending", "pending">;
261
- fetchNextPage: (options?: _tanstack_vue_query.FetchNextPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
262
- fetchPreviousPage: (options?: _tanstack_vue_query.FetchPreviousPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
263
- hasNextPage: vue.Ref<boolean, boolean>;
264
- hasPreviousPage: vue.Ref<boolean, boolean>;
265
- isFetchingNextPage: vue.Ref<boolean, boolean>;
266
- isFetchingPreviousPage: vue.Ref<boolean, boolean>;
267
- dataUpdatedAt: vue.Ref<number, number>;
268
- errorUpdatedAt: vue.Ref<number, number>;
269
- failureCount: vue.Ref<number, number>;
270
- failureReason: vue.Ref<Error | null, Error | null>;
271
- errorUpdateCount: vue.Ref<number, number>;
272
- isFetched: vue.Ref<boolean, boolean>;
273
- isFetchedAfterMount: vue.Ref<boolean, boolean>;
274
- isFetching: vue.Ref<boolean, boolean>;
275
- isInitialLoading: vue.Ref<boolean, boolean>;
276
- isPaused: vue.Ref<boolean, boolean>;
277
- isRefetching: vue.Ref<boolean, boolean>;
278
- isStale: vue.Ref<boolean, boolean>;
279
- isEnabled: vue.Ref<boolean, boolean>;
280
- refetch: (options?: _tanstack_vue_query.RefetchOptions) => Promise<_tanstack_vue_query.QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
281
- fetchStatus: vue.Ref<_tanstack_vue_query.FetchStatus, _tanstack_vue_query.FetchStatus>;
282
- promise: vue.Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
283
- suspense: () => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
284
- queryKey: [string, string, string, unknown, {
285
- infinite: boolean;
286
- optimisticUpdate: boolean;
287
- }];
231
+ data: Ref<undefined, undefined>;
232
+ error: Ref<null, null>;
233
+ isError: Ref<false, false>;
234
+ isPending: Ref<true, true>;
235
+ isLoading: Ref<true, true>;
236
+ isLoadingError: Ref<false, false>;
237
+ isRefetchError: Ref<false, false>;
238
+ isFetchNextPageError: Ref<false, false>;
239
+ isFetchPreviousPageError: Ref<false, false>;
240
+ isSuccess: Ref<false, false>;
241
+ isPlaceholderData: Ref<false, false>;
242
+ status: Ref<"pending", "pending">;
243
+ fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
244
+ fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
245
+ hasNextPage: Ref<boolean, boolean>;
246
+ hasPreviousPage: Ref<boolean, boolean>;
247
+ isFetchingNextPage: Ref<boolean, boolean>;
248
+ isFetchingPreviousPage: Ref<boolean, boolean>;
249
+ dataUpdatedAt: Ref<number, number>;
250
+ errorUpdatedAt: Ref<number, number>;
251
+ failureCount: Ref<number, number>;
252
+ failureReason: Ref<Error | null, Error | null>;
253
+ errorUpdateCount: Ref<number, number>;
254
+ isFetched: Ref<boolean, boolean>;
255
+ isFetchedAfterMount: Ref<boolean, boolean>;
256
+ isFetching: Ref<boolean, boolean>;
257
+ isInitialLoading: Ref<boolean, boolean>;
258
+ isPaused: Ref<boolean, boolean>;
259
+ isRefetching: Ref<boolean, boolean>;
260
+ isStale: Ref<boolean, boolean>;
261
+ isEnabled: Ref<boolean, boolean>;
262
+ refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
263
+ fetchStatus: Ref<import("@tanstack/query-core").FetchStatus, import("@tanstack/query-core").FetchStatus>;
264
+ promise: Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
265
+ suspense: () => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
266
+ queryKey: import("vue").ComputedRef<import("./common/query-key").QueryKey>;
288
267
  } | {
289
- data: vue.Ref<undefined, undefined>;
290
- error: vue.Ref<null, null>;
291
- isError: vue.Ref<false, false>;
292
- isPending: vue.Ref<true, true>;
293
- isLoadingError: vue.Ref<false, false>;
294
- isRefetchError: vue.Ref<false, false>;
295
- isFetchNextPageError: vue.Ref<false, false>;
296
- isFetchPreviousPageError: vue.Ref<false, false>;
297
- isSuccess: vue.Ref<false, false>;
298
- isPlaceholderData: vue.Ref<false, false>;
299
- status: vue.Ref<"pending", "pending">;
300
- fetchNextPage: (options?: _tanstack_vue_query.FetchNextPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
301
- fetchPreviousPage: (options?: _tanstack_vue_query.FetchPreviousPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
302
- hasNextPage: vue.Ref<boolean, boolean>;
303
- hasPreviousPage: vue.Ref<boolean, boolean>;
304
- isFetchingNextPage: vue.Ref<boolean, boolean>;
305
- isFetchingPreviousPage: vue.Ref<boolean, boolean>;
306
- dataUpdatedAt: vue.Ref<number, number>;
307
- errorUpdatedAt: vue.Ref<number, number>;
308
- failureCount: vue.Ref<number, number>;
309
- failureReason: vue.Ref<Error | null, Error | null>;
310
- errorUpdateCount: vue.Ref<number, number>;
311
- isFetched: vue.Ref<boolean, boolean>;
312
- isFetchedAfterMount: vue.Ref<boolean, boolean>;
313
- isFetching: vue.Ref<boolean, boolean>;
314
- isLoading: vue.Ref<boolean, boolean>;
315
- isInitialLoading: vue.Ref<boolean, boolean>;
316
- isPaused: vue.Ref<boolean, boolean>;
317
- isRefetching: vue.Ref<boolean, boolean>;
318
- isStale: vue.Ref<boolean, boolean>;
319
- isEnabled: vue.Ref<boolean, boolean>;
320
- refetch: (options?: _tanstack_vue_query.RefetchOptions) => Promise<_tanstack_vue_query.QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
321
- fetchStatus: vue.Ref<_tanstack_vue_query.FetchStatus, _tanstack_vue_query.FetchStatus>;
322
- promise: vue.Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
323
- suspense: () => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
324
- queryKey: [string, string, string, unknown, {
325
- infinite: boolean;
326
- optimisticUpdate: boolean;
327
- }];
268
+ data: Ref<undefined, undefined>;
269
+ error: Ref<null, null>;
270
+ isError: Ref<false, false>;
271
+ isPending: Ref<true, true>;
272
+ isLoadingError: Ref<false, false>;
273
+ isRefetchError: Ref<false, false>;
274
+ isFetchNextPageError: Ref<false, false>;
275
+ isFetchPreviousPageError: Ref<false, false>;
276
+ isSuccess: Ref<false, false>;
277
+ isPlaceholderData: Ref<false, false>;
278
+ status: Ref<"pending", "pending">;
279
+ fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
280
+ fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
281
+ hasNextPage: Ref<boolean, boolean>;
282
+ hasPreviousPage: Ref<boolean, boolean>;
283
+ isFetchingNextPage: Ref<boolean, boolean>;
284
+ isFetchingPreviousPage: Ref<boolean, boolean>;
285
+ dataUpdatedAt: Ref<number, number>;
286
+ errorUpdatedAt: Ref<number, number>;
287
+ failureCount: Ref<number, number>;
288
+ failureReason: Ref<Error | null, Error | null>;
289
+ errorUpdateCount: Ref<number, number>;
290
+ isFetched: Ref<boolean, boolean>;
291
+ isFetchedAfterMount: Ref<boolean, boolean>;
292
+ isFetching: Ref<boolean, boolean>;
293
+ isLoading: Ref<boolean, boolean>;
294
+ isInitialLoading: Ref<boolean, boolean>;
295
+ isPaused: Ref<boolean, boolean>;
296
+ isRefetching: Ref<boolean, boolean>;
297
+ isStale: Ref<boolean, boolean>;
298
+ isEnabled: Ref<boolean, boolean>;
299
+ refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
300
+ fetchStatus: Ref<import("@tanstack/query-core").FetchStatus, import("@tanstack/query-core").FetchStatus>;
301
+ promise: Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
302
+ suspense: () => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
303
+ queryKey: import("vue").ComputedRef<import("./common/query-key").QueryKey>;
328
304
  } | {
329
- data: vue.Ref<InfiniteData<unknown, unknown>, InfiniteData<unknown, unknown>>;
330
- isError: vue.Ref<false, false>;
331
- error: vue.Ref<null, null>;
332
- isPending: vue.Ref<false, false>;
333
- isLoading: vue.Ref<false, false>;
334
- isLoadingError: vue.Ref<false, false>;
335
- isRefetchError: vue.Ref<false, false>;
336
- isSuccess: vue.Ref<true, true>;
337
- isPlaceholderData: vue.Ref<true, true>;
338
- isFetchNextPageError: vue.Ref<false, false>;
339
- isFetchPreviousPageError: vue.Ref<false, false>;
340
- status: vue.Ref<"success", "success">;
341
- fetchNextPage: (options?: _tanstack_vue_query.FetchNextPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
342
- fetchPreviousPage: (options?: _tanstack_vue_query.FetchPreviousPageOptions) => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
343
- hasNextPage: vue.Ref<boolean, boolean>;
344
- hasPreviousPage: vue.Ref<boolean, boolean>;
345
- isFetchingNextPage: vue.Ref<boolean, boolean>;
346
- isFetchingPreviousPage: vue.Ref<boolean, boolean>;
347
- dataUpdatedAt: vue.Ref<number, number>;
348
- errorUpdatedAt: vue.Ref<number, number>;
349
- failureCount: vue.Ref<number, number>;
350
- failureReason: vue.Ref<Error | null, Error | null>;
351
- errorUpdateCount: vue.Ref<number, number>;
352
- isFetched: vue.Ref<boolean, boolean>;
353
- isFetchedAfterMount: vue.Ref<boolean, boolean>;
354
- isFetching: vue.Ref<boolean, boolean>;
355
- isInitialLoading: vue.Ref<boolean, boolean>;
356
- isPaused: vue.Ref<boolean, boolean>;
357
- isRefetching: vue.Ref<boolean, boolean>;
358
- isStale: vue.Ref<boolean, boolean>;
359
- isEnabled: vue.Ref<boolean, boolean>;
360
- refetch: (options?: _tanstack_vue_query.RefetchOptions) => Promise<_tanstack_vue_query.QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
361
- fetchStatus: vue.Ref<_tanstack_vue_query.FetchStatus, _tanstack_vue_query.FetchStatus>;
362
- promise: vue.Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
363
- suspense: () => Promise<_tanstack_vue_query.InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
364
- queryKey: [string, string, string, unknown, {
365
- infinite: boolean;
366
- optimisticUpdate: boolean;
367
- }];
305
+ data: Ref<InfiniteData<unknown, unknown>, InfiniteData<unknown, unknown>>;
306
+ isError: Ref<false, false>;
307
+ error: Ref<null, null>;
308
+ isPending: Ref<false, false>;
309
+ isLoading: Ref<false, false>;
310
+ isLoadingError: Ref<false, false>;
311
+ isRefetchError: Ref<false, false>;
312
+ isSuccess: Ref<true, true>;
313
+ isPlaceholderData: Ref<true, true>;
314
+ isFetchNextPageError: Ref<false, false>;
315
+ isFetchPreviousPageError: Ref<false, false>;
316
+ status: Ref<"success", "success">;
317
+ fetchNextPage: (options?: import("@tanstack/query-core").FetchNextPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
318
+ fetchPreviousPage: (options?: import("@tanstack/query-core").FetchPreviousPageOptions) => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
319
+ hasNextPage: Ref<boolean, boolean>;
320
+ hasPreviousPage: Ref<boolean, boolean>;
321
+ isFetchingNextPage: Ref<boolean, boolean>;
322
+ isFetchingPreviousPage: Ref<boolean, boolean>;
323
+ dataUpdatedAt: Ref<number, number>;
324
+ errorUpdatedAt: Ref<number, number>;
325
+ failureCount: Ref<number, number>;
326
+ failureReason: Ref<Error | null, Error | null>;
327
+ errorUpdateCount: Ref<number, number>;
328
+ isFetched: Ref<boolean, boolean>;
329
+ isFetchedAfterMount: Ref<boolean, boolean>;
330
+ isFetching: Ref<boolean, boolean>;
331
+ isInitialLoading: Ref<boolean, boolean>;
332
+ isPaused: Ref<boolean, boolean>;
333
+ isRefetching: Ref<boolean, boolean>;
334
+ isStale: Ref<boolean, boolean>;
335
+ isEnabled: Ref<boolean, boolean>;
336
+ refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
337
+ fetchStatus: Ref<import("@tanstack/query-core").FetchStatus, import("@tanstack/query-core").FetchStatus>;
338
+ promise: Ref<Promise<InfiniteData<unknown, unknown>>, Promise<InfiniteData<unknown, unknown>>>;
339
+ suspense: () => Promise<import("@tanstack/query-core").InfiniteQueryObserverResult<InfiniteData<unknown, unknown>, Error>>;
340
+ queryKey: import("vue").ComputedRef<import("./common/query-key").QueryKey>;
368
341
  };
369
342
  /**
370
343
  * Creates a vue-query mutation
@@ -377,6 +350,4 @@ declare function useInternalInfiniteQuery<TQueryFnData, TData>(_schema: SchemaDe
377
350
  * @param options The vue-query options.
378
351
  * @param checkReadBack Whether to check for read back errors and return undefined if found.
379
352
  */
380
- 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">>;
381
-
382
- 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 };
353
+ export 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<R, Error, TArgs, unknown, Omit<import("@tanstack/query-core").MutationObserverIdleResult<R, Error, TArgs, unknown>, "mutate" | "reset"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<R, Error, TArgs, unknown>, "mutate" | "reset"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<R, Error, TArgs, unknown>, "mutate" | "reset"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<R, Error, TArgs, unknown>, "mutate" | "reset">>;