@strato-admin/faker-ecommerce 0.1.0 → 0.3.0

package/dist/ra-core/src/dataProvider/useDeleteMany.js

@@ -0,0 +1,193 @@
+import { useQueryClient, } from '@tanstack/react-query';
+import { useDataProvider } from './useDataProvider';
+import { useEvent } from '../util';
+import { useMutationWithMutationMode, } from './useMutationWithMutationMode';
+/**
+ * Get a callback to call the dataProvider.delete() method, the result and the loading state.
+ *
+ * @param {string} resource
+ * @param {Params} params The delete parameters { ids }
+ * @param {Object} options Options object to pass to the queryClient.
+ * May include side effects to be executed upon success or failure, e.g. { onSuccess: () => { refresh(); } }
+ * May include a mutation mode (optimistic/pessimistic/undoable), e.g. { mutationMode: 'undoable' }
+ *
+ * @typedef Params
+ * @prop params.ids The resource identifiers, e.g. [123, 456]
+ *
+ * @returns The current mutation state. Destructure as [deleteMany, { data, error, isPending }].
+ *
+ * The return value updates according to the request state:
+ *
+ * - initial: [deleteMany, { isPending: false, isIdle: true }]
+ * - start:   [deleteMany, { isPending: true }]
+ * - success: [deleteMany, { data: [data from response], isPending: false, isSuccess: true }]
+ * - error:   [deleteMany, { error: [error from response], isPending: false, isError: true }]
+ *
+ * The deleteMany() function must be called with a resource and a parameter object: deleteMany(resource, { ids, meta }, options)
+ *
+ * This hook uses react-query useMutation under the hood.
+ * This means the state object contains mutate, isIdle, reset and other react-query methods.
+ *
+ * @see https://tanstack.com/query/v5/docs/react/reference/useMutation
+ *
+ * @example // set params when calling the deleteMany callback
+ *
+ * import { useDeleteMany } from 'react-admin';
+ *
+ * const BulkDeletePostsButton = ({ selectedIds }) => {
+ *     const [deleteMany, { isPending, error }] = useDeleteMany();
+ *     const handleClick = () => {
+ *         deleteMany('posts', { ids: selectedIds })
+ *     }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={handleClick}>Delete selected posts</button>;
+ * };
+ *
+ * @example // set params when calling the hook
+ *
+ * import { useDeleteMany } from 'react-admin';
+ *
+ * const BulkDeletePostsButton = ({ selectedIds }) => {
+ *     const [deleteMany, { isPending, error }] = useDeleteMany('posts', { ids: selectedIds });
+ *     const handleClick = () => {
+ *         deleteMany()
+ *     }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={handleClick}>Delete selected posts</button>;
+ * };
+ *
+ * @example // TypeScript
+ * const [deleteMany, { data }] = useDeleteMany<Product>('products', { ids });
+ *                        \-- data is Product
+ */
+export const useDeleteMany = (resource, params = {}, options = {}) => {
+    const dataProvider = useDataProvider();
+    const queryClient = useQueryClient();
+    const { mutationMode = 'pessimistic', onSettled, ...mutationOptions } = options;
+    const [mutate, mutationResult] = useMutationWithMutationMode({ resource, ...params }, {
+        ...mutationOptions,
+        mutationKey: [resource, 'deleteMany', params],
+        mutationMode,
+        mutationFn: ({ resource, ...params }) => {
+            if (resource == null) {
+                throw new Error('useDeleteMany mutation requires a resource');
+            }
+            if (params.ids == null) {
+                throw new Error('useDeleteMany mutation requires an array of ids');
+            }
+            return dataProvider.deleteMany(resource, params);
+        },
+        updateCache: ({ resource, ...params }, { mutationMode }) => {
+            // hack: only way to tell react-query not to fetch this query for the next 5 seconds
+            // because setQueryData doesn't accept a stale time option
+            const now = Date.now();
+            const updatedAt = mutationMode === 'undoable' ? now + 5 * 1000 : now;
+            const updateColl = (old) => {
+                if (!old)
+                    return old;
+                let newCollection = [...old];
+                params.ids?.forEach(id => {
+                    const index = newCollection.findIndex(
+                    // eslint-disable-next-line eqeqeq
+                    record => record.id == id);
+                    if (index === -1) {
+                        return;
+                    }
+                    newCollection = [
+                        ...newCollection.slice(0, index),
+                        ...newCollection.slice(index + 1),
+                    ];
+                });
+                return newCollection;
+            };
+            queryClient.setQueriesData({ queryKey: [resource, 'getList'] }, (res) => {
+                if (!res || !res.data)
+                    return res;
+                const newCollection = updateColl(res.data);
+                const recordWasFound = newCollection.length < res.data.length;
+                return recordWasFound
+                    ? {
+                        ...res,
+                        data: newCollection,
+                        total: res.total
+                            ? res.total -
+                                (res.data.length - newCollection.length)
+                            : undefined,
+                    }
+                    : res;
+            }, { updatedAt });
+            queryClient.setQueriesData({ queryKey: [resource, 'getInfiniteList'] }, (res) => {
+                if (!res || !res.pages)
+                    return res;
+                return {
+                    ...res,
+                    pages: res.pages.map(page => {
+                        const newCollection = updateColl(page.data);
+                        const recordWasFound = newCollection.length < page.data.length;
+                        return recordWasFound
+                            ? {
+                                ...page,
+                                data: newCollection,
+                                total: page.total
+                                    ? page.total -
+                                        (page.data.length -
+                                            newCollection.length)
+                                    : undefined,
+                            }
+                            : page;
+                    }),
+                };
+            }, { updatedAt });
+            queryClient.setQueriesData({ queryKey: [resource, 'getMany'] }, (coll) => coll && coll.length > 0 ? updateColl(coll) : coll, { updatedAt });
+            queryClient.setQueriesData({ queryKey: [resource, 'getManyReference'] }, (res) => {
+                if (!res || !res.data)
+                    return res;
+                const newCollection = updateColl(res.data);
+                const recordWasFound = newCollection.length < res.data.length;
+                if (!recordWasFound) {
+                    return res;
+                }
+                if (res.total) {
+                    return {
+                        ...res,
+                        data: newCollection,
+                        total: res.total -
+                            (res.data.length - newCollection.length),
+                    };
+                }
+                if (res.pageInfo) {
+                    return {
+                        ...res,
+                        data: newCollection,
+                    };
+                }
+                throw new Error('Found getManyReference result in cache without total or pageInfo');
+            }, { updatedAt });
+            return params.ids;
+        },
+        getQueryKeys: ({ resource }) => {
+            const queryKeys = [
+                [resource, 'getList'],
+                [resource, 'getInfiniteList'],
+                [resource, 'getMany'],
+                [resource, 'getManyReference'],
+            ];
+            return queryKeys;
+        },
+        onSettled: (...args) => {
+            const [, , , mutateResult] = args;
+            // For deletion, we always refetch after error or success:
+            mutateResult.snapshot.forEach(([queryKey]) => {
+                queryClient.invalidateQueries({ queryKey });
+            });
+            onSettled?.(...args);
+        },
+    });
+    const deleteMany = useEvent((callTimeResource = resource, callTimeParams = {}, callTimeOptions = {}) => {
+        return mutate({
+            resource: callTimeResource,
+            ...callTimeParams,
+        }, callTimeOptions);
+    });
+    return [deleteMany, mutationResult];
+};

package/dist/ra-core/src/dataProvider/useGetList.d.ts

@@ -0,0 +1,58 @@
+import { UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import { RaRecord, GetListParams, GetListResult } from '../types';
+/**
+ * Call the dataProvider.getList() method and return the resolved result
+ * as well as the loading state.
+ *
+ * The return value updates according to the request state:
+ *
+ * - start: { isPending: true, refetch }
+ * - success: { data: [data from store], total: [total from response], isPending: false, refetch }
+ * - error: { error: [error from response], isPending: false, refetch }
+ *
+ * This hook will return the cached result when called a second time
+ * with the same parameters, until the response arrives.
+ *
+ * @param {string} resource The resource name, e.g. 'posts'
+ * @param {Params} params The getList parameters { pagination, sort, filter, meta }
+ * @param {Object} options Options object to pass to the queryClient.
+ * May include side effects to be executed upon success or failure, e.g. { onSuccess: () => { refresh(); } }
+ *
+ * @typedef Params
+ * @prop params.pagination The request pagination { page, perPage }, e.g. { page: 1, perPage: 10 }
+ * @prop params.sort The request sort { field, order }, e.g. { field: 'id', order: 'DESC' }
+ * @prop params.filter The request filters, e.g. { title: 'hello, world' }
+ * @prop params.meta Optional meta parameters
+ *
+ * @returns The current request state. Destructure as { data, total, error, isPending, refetch }.
+ *
+ * @example
+ *
+ * import { useGetList } from 'react-admin';
+ *
+ * const LatestNews = () => {
+ *     const { data, total, isPending, error } = useGetList(
+ *         'posts',
+ *         { pagination: { page: 1, perPage: 10 }, sort: { field: 'published_at', order: 'DESC' } }
+ *     );
+ *     if (isPending) { return <Loading />; }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <ul>{data.map(item =>
+ *         <li key={item.id}>{item.title}</li>
+ *     )}</ul>;
+ * };
+ */
+export declare const useGetList: <RecordType extends RaRecord = any, ErrorType = Error>(resource: string, params?: Partial<GetListParams>, options?: UseGetListOptions<RecordType, ErrorType>) => UseGetListHookValue<RecordType>;
+export type UseGetListOptions<RecordType extends RaRecord = any, ErrorType = Error> = Omit<UseQueryOptions<GetListResult<RecordType>, ErrorType>, 'queryKey' | 'queryFn'> & {
+    onSuccess?: (value: GetListResult<RecordType>) => void;
+    onError?: (error: ErrorType) => void;
+    onSettled?: (data?: GetListResult<RecordType>, error?: ErrorType | null) => void;
+};
+export type UseGetListHookValue<RecordType extends RaRecord = any> = UseQueryResult<RecordType[], Error> & {
+    total?: number;
+    pageInfo?: {
+        hasNextPage?: boolean;
+        hasPreviousPage?: boolean;
+    };
+    meta?: any;
+};

package/dist/ra-core/src/dataProvider/useGetList.js

@@ -0,0 +1,131 @@
+import { useEffect, useMemo, useRef } from 'react';
+import { useQuery, useQueryClient, } from '@tanstack/react-query';
+import { useDataProvider } from './useDataProvider';
+import { useEvent } from '../util';
+const MAX_DATA_LENGTH_TO_CACHE = 100;
+/**
+ * Call the dataProvider.getList() method and return the resolved result
+ * as well as the loading state.
+ *
+ * The return value updates according to the request state:
+ *
+ * - start: { isPending: true, refetch }
+ * - success: { data: [data from store], total: [total from response], isPending: false, refetch }
+ * - error: { error: [error from response], isPending: false, refetch }
+ *
+ * This hook will return the cached result when called a second time
+ * with the same parameters, until the response arrives.
+ *
+ * @param {string} resource The resource name, e.g. 'posts'
+ * @param {Params} params The getList parameters { pagination, sort, filter, meta }
+ * @param {Object} options Options object to pass to the queryClient.
+ * May include side effects to be executed upon success or failure, e.g. { onSuccess: () => { refresh(); } }
+ *
+ * @typedef Params
+ * @prop params.pagination The request pagination { page, perPage }, e.g. { page: 1, perPage: 10 }
+ * @prop params.sort The request sort { field, order }, e.g. { field: 'id', order: 'DESC' }
+ * @prop params.filter The request filters, e.g. { title: 'hello, world' }
+ * @prop params.meta Optional meta parameters
+ *
+ * @returns The current request state. Destructure as { data, total, error, isPending, refetch }.
+ *
+ * @example
+ *
+ * import { useGetList } from 'react-admin';
+ *
+ * const LatestNews = () => {
+ *     const { data, total, isPending, error } = useGetList(
+ *         'posts',
+ *         { pagination: { page: 1, perPage: 10 }, sort: { field: 'published_at', order: 'DESC' } }
+ *     );
+ *     if (isPending) { return <Loading />; }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <ul>{data.map(item =>
+ *         <li key={item.id}>{item.title}</li>
+ *     )}</ul>;
+ * };
+ */
+export const useGetList = (resource, params = {}, options = {}) => {
+    const { pagination = { page: 1, perPage: 25 }, sort = { field: 'id', order: 'DESC' }, filter = {}, meta, } = params;
+    const dataProvider = useDataProvider();
+    const queryClient = useQueryClient();
+    const { onError = noop, onSuccess = noop, onSettled = noop, ...queryOptions } = options;
+    const onSuccessEvent = useEvent(onSuccess);
+    const onErrorEvent = useEvent(onError);
+    const onSettledEvent = useEvent(onSettled);
+    const result = useQuery({
+        queryKey: [resource, 'getList', { pagination, sort, filter, meta }],
+        queryFn: queryParams => dataProvider
+            .getList(resource, {
+            pagination,
+            sort,
+            filter,
+            meta,
+            signal: dataProvider.supportAbortSignal === true
+                ? queryParams.signal
+                : undefined,
+        })
+            .then(({ data, total, pageInfo, meta }) => ({
+            data,
+            total,
+            pageInfo,
+            meta,
+        })),
+        ...queryOptions,
+    });
+    const metaValue = useRef(meta);
+    const resourceValue = useRef(resource);
+    useEffect(() => {
+        metaValue.current = meta;
+    }, [meta]);
+    useEffect(() => {
+        resourceValue.current = resource;
+    }, [resource]);
+    useEffect(() => {
+        if (result.data === undefined ||
+            result.error != null ||
+            result.isFetching)
+            return;
+        // optimistically populate the getOne cache
+        if (result.data?.data &&
+            result.data.data.length <= MAX_DATA_LENGTH_TO_CACHE) {
+            result.data.data.forEach(record => {
+                queryClient.setQueryData([
+                    resourceValue.current,
+                    'getOne',
+                    { id: String(record.id), meta: metaValue.current },
+                ], oldRecord => oldRecord ?? record);
+            });
+        }
+        onSuccessEvent(result.data);
+    }, [
+        onSuccessEvent,
+        queryClient,
+        result.data,
+        result.error,
+        result.isFetching,
+    ]);
+    useEffect(() => {
+        if (result.error == null || result.isFetching)
+            return;
+        onErrorEvent(result.error);
+    }, [onErrorEvent, result.error, result.isFetching]);
+    useEffect(() => {
+        if (result.status === 'pending' || result.isFetching)
+            return;
+        onSettledEvent(result.data, result.error);
+    }, [
+        onSettledEvent,
+        result.data,
+        result.error,
+        result.status,
+        result.isFetching,
+    ]);
+    return useMemo(() => result.data
+        ? {
+            ...result,
+            ...result.data,
+        }
+        : result, [result]);
+};
+const noop = () => undefined;

package/dist/ra-core/src/dataProvider/useGetMany.d.ts

@@ -0,0 +1,49 @@
+import { UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import { RaRecord, GetManyParams } from '../types';
+/**
+ * Call the dataProvider.getMany() method and return the resolved result
+ * as well as the loading state.
+ *
+ * The return value updates according to the request state:
+ *
+ * - start: { isPending: true, refetch }
+ * - success: { data: [data from store], isPending: false, refetch }
+ * - error: { error: [error from response], isPending: false, refetch }
+ *
+ * This hook will return the cached result when called a second time
+ * with the same parameters, until the response arrives.
+ *
+ * @param {string} resource The resource name, e.g. 'posts'
+ * @param {Params} params The getMany parameters { ids, meta }
+ * @param {Object} options Options object to pass to the queryClient.
+ * May include side effects to be executed upon success or failure, e.g. { onSuccess: () => { refresh(); } }
+ *
+ * @typedef Params
+ * @prop params.ids The ids to get, e.g. [123, 456, 789]
+ * @prop params.meta Optional meta parameters
+ *
+ * @returns The current request state. Destructure as { data, error, isPending, refetch }.
+ *
+ * @example
+ *
+ * import { useGetMany } from 'react-admin';
+ *
+ * const PostTags = ({ post }) => {
+ *     const { data, isPending, error } = useGetMany(
+ *         'tags',
+ *         { ids: post.tags },
+ *     );
+ *     if (isPending) { return <Loading />; }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <ul>{data.map(tag =>
+ *         <li key={tag.id}>{tag.name}</li>
+ *     )}</ul>;
+ * };
+ */
+export declare const useGetMany: <RecordType extends RaRecord = any, ErrorType = Error>(resource: string, params: Partial<GetManyParams<RecordType>>, options?: UseGetManyOptions<RecordType, ErrorType>) => UseGetManyHookValue<RecordType, ErrorType>;
+export type UseGetManyOptions<RecordType extends RaRecord = any, ErrorType = Error> = Omit<UseQueryOptions<RecordType[], ErrorType>, 'queryKey' | 'queryFn'> & {
+    onSuccess?: (data: RecordType[]) => void;
+    onError?: (error: ErrorType) => void;
+    onSettled?: (data?: RecordType[], error?: ErrorType | null) => void;
+};
+export type UseGetManyHookValue<RecordType extends RaRecord = any, ErrorType = Error> = UseQueryResult<RecordType[], ErrorType>;

package/dist/ra-core/src/dataProvider/useGetMany.js

@@ -0,0 +1,143 @@
+import { useEffect, useRef } from 'react';
+import { useQuery, useQueryClient, } from '@tanstack/react-query';
+import { useDataProvider } from './useDataProvider';
+import { useEvent } from '../util';
+/**
+ * Call the dataProvider.getMany() method and return the resolved result
+ * as well as the loading state.
+ *
+ * The return value updates according to the request state:
+ *
+ * - start: { isPending: true, refetch }
+ * - success: { data: [data from store], isPending: false, refetch }
+ * - error: { error: [error from response], isPending: false, refetch }
+ *
+ * This hook will return the cached result when called a second time
+ * with the same parameters, until the response arrives.
+ *
+ * @param {string} resource The resource name, e.g. 'posts'
+ * @param {Params} params The getMany parameters { ids, meta }
+ * @param {Object} options Options object to pass to the queryClient.
+ * May include side effects to be executed upon success or failure, e.g. { onSuccess: () => { refresh(); } }
+ *
+ * @typedef Params
+ * @prop params.ids The ids to get, e.g. [123, 456, 789]
+ * @prop params.meta Optional meta parameters
+ *
+ * @returns The current request state. Destructure as { data, error, isPending, refetch }.
+ *
+ * @example
+ *
+ * import { useGetMany } from 'react-admin';
+ *
+ * const PostTags = ({ post }) => {
+ *     const { data, isPending, error } = useGetMany(
+ *         'tags',
+ *         { ids: post.tags },
+ *     );
+ *     if (isPending) { return <Loading />; }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <ul>{data.map(tag =>
+ *         <li key={tag.id}>{tag.name}</li>
+ *     )}</ul>;
+ * };
+ */
+export const useGetMany = (resource, params, options = {}) => {
+    const { ids, meta } = params;
+    const dataProvider = useDataProvider();
+    const queryClient = useQueryClient();
+    const { onError = noop, onSuccess = noop, onSettled = noop, enabled, ...queryOptions } = options;
+    const onSuccessEvent = useEvent(onSuccess);
+    const onErrorEvent = useEvent(onError);
+    const onSettledEvent = useEvent(onSettled);
+    const result = useQuery({
+        queryKey: [
+            resource,
+            'getMany',
+            {
+                ids: !ids || ids.length === 0 ? [] : ids.map(id => String(id)),
+                meta,
+            },
+        ],
+        queryFn: queryParams => {
+            if (!ids || ids.length === 0) {
+                // no need to call the dataProvider
+                return Promise.resolve([]);
+            }
+            return dataProvider
+                .getMany(resource, {
+                ids,
+                meta,
+                signal: dataProvider.supportAbortSignal === true
+                    ? queryParams.signal
+                    : undefined,
+            })
+                .then(({ data }) => data);
+        },
+        placeholderData: () => {
+            const records = !ids || ids.length === 0
+                ? []
+                : ids.map(id => queryClient.getQueryData([
+                    resource,
+                    'getOne',
+                    { id: String(id), meta },
+                ]));
+            if (records.some(record => record === undefined)) {
+                return undefined;
+            }
+            else {
+                return records;
+            }
+        },
+        retry: false,
+        enabled: enabled ?? ids != null,
+        ...queryOptions,
+    });
+    const metaValue = useRef(meta);
+    const resourceValue = useRef(resource);
+    useEffect(() => {
+        metaValue.current = meta;
+    }, [meta]);
+    useEffect(() => {
+        resourceValue.current = resource;
+    }, [resource]);
+    useEffect(() => {
+        if (result.data === undefined ||
+            result.error != null ||
+            result.isFetching)
+            return;
+        // optimistically populate the getOne cache
+        result.data.forEach(record => {
+            queryClient.setQueryData([
+                resourceValue.current,
+                'getOne',
+                { id: String(record.id), meta: metaValue.current },
+            ], oldRecord => oldRecord ?? record);
+        });
+        onSuccessEvent(result.data);
+    }, [
+        queryClient,
+        onSuccessEvent,
+        result.data,
+        result.error,
+        result.isFetching,
+    ]);
+    useEffect(() => {
+        if (result.error == null || result.isFetching)
+            return;
+        onErrorEvent(result.error);
+    }, [onErrorEvent, result.error, result.isFetching]);
+    useEffect(() => {
+        if (result.status === 'pending' || result.isFetching)
+            return;
+        onSettledEvent(result.data, result.error);
+    }, [
+        onSettledEvent,
+        result.data,
+        result.error,
+        result.status,
+        result.isFetching,
+    ]);
+    return result;
+};
+const noop = () => undefined;

package/dist/ra-core/src/dataProvider/useGetManyAggregate.d.ts

@@ -0,0 +1,62 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import { UseGetManyHookValue } from './useGetMany';
+import { RaRecord, GetManyParams } from '../types';
+/**
+ * Call the dataProvider.getMany() method and return the resolved result
+ * as well as the loading state.
+ *
+ * The return value updates according to the request state:
+ *
+ * - start: { isPending: true, isFetching: true, refetch }
+ * - success: { data: [data from response], isPending: false, isFetching: false, refetch }
+ * - error: { error: [error from response], isPending: false, isFetching: false, refetch }
+ *
+ * This hook will return the cached result when called a second time
+ * with the same parameters, until the response arrives.
+ *
+ * This hook aggregates and deduplicates calls to the same resource, so for instance, if an app calls:
+ *
+ * useGetManyAggregate('tags', [1, 2, 3]);
+ * useGetManyAggregate('tags', [3, 4]);
+ *
+ * during the same tick, the hook will only call the dataProvider once with the following parameters:
+ *
+ * dataProvider.getMany('tags', [1, 2, 3, 4])
+ *
+ * @param resource The resource name, e.g. 'posts'
+ * @param {Params} params The getMany parameters { ids, meta }
+ * @param {Object} options Options object to pass to the dataProvider.
+ * @param {boolean} options.enabled Flag to conditionally run the query. If it's false, the query will not run
+ * @param {Function} options.onSuccess Side effect function to be executed upon success, e.g. { onSuccess: { refresh: true } }
+ * @param {Function} options.onError Side effect function to be executed upon failure, e.g. { onError: error => notify(error.message) }
+ *
+ * @typedef Params
+ * @prop params.ids The ids to get, e.g. [123, 456, 789]
+ * @prop params.meta Optional meta parameters
+
+ * @returns The current request state. Destructure as { data, error, isPending, isFetching, refetch }.
+ *
+ * @example
+ *
+ * import { useGetManyAggregate, useRecordContext } from 'react-admin';
+ *
+ * const PostTags = () => {
+ *     const record = useRecordContext();
+ *     const { data, isPending, error } = useGetManyAggregate('tags', { ids: record.tagIds });
+ *     if (isPending) { return <Loading />; }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return (
+ *          <ul>
+ *              {data.map(tag => (
+ *                  <li key={tag.id}>{tag.name}</li>
+ *              ))}
+ *          </ul>
+ *      );
+ * };
+ */
+export declare const useGetManyAggregate: <RecordType extends RaRecord = any, ErrorType = Error>(resource: string, params: Partial<GetManyParams<RecordType>>, options?: UseGetManyAggregateOptions<RecordType, ErrorType>) => UseGetManyHookValue<RecordType, ErrorType>;
+export type UseGetManyAggregateOptions<RecordType extends RaRecord = any, ErrorType = Error> = Omit<UseQueryOptions<RecordType[], ErrorType>, 'queryKey' | 'queryFn'> & {
+    onSuccess?: (data: RecordType[]) => void;
+    onError?: (error: ErrorType) => void;
+    onSettled?: (data?: RecordType[], error?: ErrorType | null) => void;
+};