@strato-admin/faker-ecommerce 0.1.0 → 0.3.0

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

@@ -0,0 +1,155 @@
+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.create() method, the result and the loading state.
+ *
+ * @param {string} resource
+ * @param {Params} params The create parameters { data }
+ * @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.data The record to create, e.g. { title: 'hello, world' }
+ *
+ * @returns The current mutation state. Destructure as [create, { data, error, isPending }].
+ *
+ * The return value updates according to the request state:
+ *
+ * - initial: [create, { isPending: false, isIdle: true }]
+ * - start:   [create, { isPending: true }]
+ * - success: [create, { data: [data from response], isPending: false, isSuccess: true }]
+ * - error:   [create, { error: [error from response], isPending: false, isError: true }]
+ *
+ * The create() function must be called with a resource and a parameter object: create(resource, { data, 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 create callback
+ *
+ * import { useCreate, useRecordContext } from 'react-admin';
+ *
+ * const LikeButton = () => {
+ *     const record = useRecordContext();
+ *     const like = { postId: record.id };
+ *     const [create, { isPending, error }] = useCreate();
+ *     const handleClick = () => {
+ *         create('likes', { data: like })
+ *     }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={handleClick}>Like</button>;
+ * };
+ *
+ * @example // set params when calling the hook
+ *
+ * import { useCreate, useRecordContext } from 'react-admin';
+ *
+ * const LikeButton = () => {
+ *     const record = useRecordContext();
+ *     const like = { postId: record.id };
+ *     const [create, { isPending, error }] = useCreate('likes', { data: like });
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={() => create()}>Like</button>;
+ * };
+ *
+ * @example // TypeScript
+ * const [create, { data }] = useCreate<Product>('products', { data: product });
+ *                    \-- data is Product
+ */
+export const useCreate = (resource, params = {}, options = {}) => {
+    const dataProvider = useDataProvider();
+    const queryClient = useQueryClient();
+    const { mutationMode = 'pessimistic', getMutateWithMiddlewares, onSettled, ...mutationOptions } = options;
+    const dataProviderCreate = useEvent((resource, params) => dataProvider.create(resource, params));
+    const [mutate, mutationResult] = useMutationWithMutationMode({ resource, ...params }, {
+        ...mutationOptions,
+        mutationKey: [resource, 'create', params],
+        mutationMode,
+        mutationFn: ({ resource, ...params }) => {
+            if (resource == null) {
+                throw new Error('useCreate mutation requires a resource');
+            }
+            if (params.data == null) {
+                throw new Error('useCreate mutation requires a non-empty data object');
+            }
+            return dataProviderCreate(resource, params);
+        },
+        updateCache: ({ resource, ...params }, { mutationMode }, result) => {
+            const id = mutationMode === 'pessimistic'
+                ? result?.id
+                : params.data?.id;
+            if (!id) {
+                throw new Error('Invalid dataProvider response for create: missing id');
+            }
+            // 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;
+            // Stringify and parse the data to remove undefined values.
+            // If we don't do this, an update with { id: undefined } as payload
+            // would remove the id from the record, which no real data provider does.
+            const clonedData = JSON.parse(JSON.stringify(mutationMode === 'pessimistic' ? result : params.data));
+            queryClient.setQueryData([resource, 'getOne', { id: String(id), meta: params.meta }], (record) => ({ ...record, ...clonedData }), { updatedAt });
+            return clonedData;
+        },
+        getQueryKeys: ({ resource, ...params }, { mutationMode }) => {
+            const queryKeys = [
+                [resource, 'getList'],
+                [resource, 'getInfiniteList'],
+                [resource, 'getMany'],
+                [resource, 'getManyReference'],
+            ];
+            if (mutationMode !== 'pessimistic' && params.data?.id) {
+                queryKeys.push([
+                    resource,
+                    'getOne',
+                    { id: String(params.data.id), meta: params.meta },
+                ]);
+            }
+            return queryKeys;
+        },
+        getMutateWithMiddlewares: mutationFn => {
+            if (getMutateWithMiddlewares) {
+                // Immediately get the function with middlewares applied so that even if the middlewares gets unregistered (because of a redirect for instance),
+                // we still have them applied when users have called the mutate function.
+                const mutateWithMiddlewares = getMutateWithMiddlewares(dataProviderCreate.bind(dataProvider));
+                return args => {
+                    // This is necessary to avoid breaking changes in useCreate:
+                    // The mutation function must have the same signature as before (resource, params) and not ({ resource, params })
+                    const { resource, ...params } = args;
+                    return mutateWithMiddlewares(resource, params);
+                };
+            }
+            return args => mutationFn(args);
+        },
+        onUndo: ({ resource, data, meta }) => {
+            queryClient.removeQueries({
+                queryKey: [
+                    resource,
+                    'getOne',
+                    { id: String(data?.id), meta },
+                ],
+                exact: true,
+            });
+        },
+        onSettled: (...args) => {
+            const [, , , mutateResult] = args;
+            // For creation, we always refetch after error or success:
+            mutateResult.snapshot.forEach(([queryKey]) => {
+                queryClient.invalidateQueries({ queryKey });
+            });
+            onSettled?.(...args);
+        },
+    });
+    const create = useEvent((callTimeResource = resource, callTimeParams = {}, callTimeOptions = {}) => {
+        return mutate({
+            resource: callTimeResource,
+            ...callTimeParams,
+        }, callTimeOptions);
+    });
+    return [create, mutationResult];
+};

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

@@ -0,0 +1,2 @@
+import { DataProvider } from '../types';
+export declare const useDataProvider: <TDataProvider extends DataProvider = DataProvider>() => TDataProvider;

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

@@ -0,0 +1,140 @@
+import { useContext, useMemo } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+import DataProviderContext from './DataProviderContext';
+import { defaultDataProvider } from './defaultDataProvider';
+import validateResponseFormat from './validateResponseFormat';
+import useLogoutIfAccessDenied from '../auth/useLogoutIfAccessDenied';
+import { reactAdminFetchActions } from './dataFetchActions';
+import { populateQueryCache } from './populateQueryCache';
+/**
+ * Hook for getting a dataProvider
+ *
+ * Gets a dataProvider object, which behaves just like the real dataProvider
+ * (same methods returning a Promise). But it's actually a Proxy object,
+ * which validates the response format, and logs the user out upon error
+ * if authProvider.checkError() rejects.
+ *
+ * @return dataProvider
+ *
+ * @example Basic usage
+ *
+ * import * as React from 'react';
+ * import { useState } from 'react';
+ * import { useDataProvider } from 'react-admin';
+ *
+ * const PostList = () => {
+ *      const [posts, setPosts] = useState([])
+ *      const dataProvider = useDataProvider();
+ *      useEffect(() => {
+ *          dataProvider.getList('posts', { filter: { status: 'pending' }})
+ *            .then(({ data }) => setPosts(data));
+ *      }, [])
+ *
+ *      return (
+ *          <Fragment>
+ *              {posts.map((post, key) => <PostDetail post={post} key={key} />)}
+ *          </Fragment>
+ *     );
+ * }
+ *
+ * @example Handling all states (loading, error, success)
+ *
+ * import { useState, useEffect } from 'react';
+ * import { useDataProvider } from 'react-admin';
+ *
+ * const UserProfile = ({ userId }) => {
+ *     const dataProvider = useDataProvider();
+ *     const [user, setUser] = useState();
+ *     const [loading, setLoading] = useState(true);
+ *     const [error, setError] = useState();
+ *     useEffect(() => {
+ *         dataProvider.getOne('users', { id: userId })
+ *             .then(({ data }) => {
+ *                 setUser(data);
+ *                 setLoading(false);
+ *             })
+ *             .catch(error => {
+ *                 setError(error);
+ *                 setLoading(false);
+ *             })
+ *     }, []);
+ *
+ *     if (loading) return <Loading />;
+ *     if (error) return <Error />
+ *     if (!user) return null;
+ *
+ *     return (
+ *         <ul>
+ *             <li>Name: {user.name}</li>
+ *             <li>Email: {user.email}</li>
+ *         </ul>
+ *     )
+ * }
+ */
+const arrayReturnTypes = ['getList', 'getMany', 'getManyReference'];
+export const useDataProvider = () => {
+    const dataProvider = (useContext(DataProviderContext) ||
+        defaultDataProvider);
+    const queryClient = useQueryClient();
+    const logoutIfAccessDenied = useLogoutIfAccessDenied();
+    const dataProviderProxy = useMemo(() => {
+        return new Proxy(dataProvider, {
+            get: (_, name) => {
+                if (typeof name === 'symbol' || name === 'then') {
+                    return;
+                }
+                if (name === 'supportAbortSignal') {
+                    return dataProvider.supportAbortSignal;
+                }
+                return (...args) => {
+                    const type = name.toString();
+                    if (typeof dataProvider[type] !== 'function') {
+                        throw new Error(`Unknown dataProvider function: ${type}`);
+                    }
+                    try {
+                        return dataProvider[type]
+                            .apply(dataProvider, args)
+                            .then(response => {
+                            if (process.env.NODE_ENV === 'development' &&
+                                reactAdminFetchActions.includes(type)) {
+                                validateResponseFormat(response, type);
+                            }
+                            if (response?.meta?.prefetched) {
+                                populateQueryCache({
+                                    data: response?.meta.prefetched,
+                                    queryClient,
+                                });
+                            }
+                            return response;
+                        })
+                            .catch(error => {
+                            if (process.env.NODE_ENV !== 'production' &&
+                                // do not log AbortErrors
+                                !isAbortError(error)) {
+                                console.error(error);
+                            }
+                            return logoutIfAccessDenied(error).then(loggedOut => {
+                                if (loggedOut)
+                                    return {
+                                        data: arrayReturnTypes.includes(type)
+                                            ? []
+                                            : {},
+                                    };
+                                throw error;
+                            });
+                        });
+                    }
+                    catch (e) {
+                        if (process.env.NODE_ENV !== 'production') {
+                            console.error(e);
+                        }
+                        throw new Error('The dataProvider threw an error. It should return a rejected Promise instead.');
+                    }
+                };
+            },
+        });
+    }, [dataProvider, logoutIfAccessDenied, queryClient]);
+    return dataProviderProxy;
+};
+const isAbortError = error => error instanceof DOMException &&
+    error.name === 'AbortError';

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

@@ -0,0 +1,83 @@
+import { type UseMutationOptions, type UseMutationResult, type MutateOptions } from '@tanstack/react-query';
+import type { RaRecord, DeleteParams, MutationMode } from '../types';
+/**
+ * Get a callback to call the dataProvider.delete() method, the result and the loading state.
+ *
+ * @param {string} resource
+ * @param {Params} params The delete parameters { id, previousData }
+ * @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.id The resource identifier, e.g. 123
+ * @prop params.previousData The record before the update is applied
+ *
+ * @returns The current mutation state. Destructure as [deleteOne, { data, error, isPending }].
+ *
+ * The return value updates according to the request state:
+ *
+ * - initial: [deleteOne, { isPending: false, isIdle: true }]
+ * - start:   [deleteOne, { isPending: true }]
+ * - success: [deleteOne, { data: [data from response], isPending: false, isSuccess: true }]
+ * - error:   [deleteOne, { error: [error from response], isPending: false, isError: true }]
+ *
+ * The deleteOne() function must be called with a resource and a parameter object: deleteOne(resource, { id, previousData, 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 deleteOne callback
+ *
+ * import { useDelete, useRecordContext } from 'react-admin';
+ *
+ * const DeleteButton = () => {
+ *     const record = useRecordContext();
+ *     const [deleteOne, { isPending, error }] = useDelete();
+ *     const handleClick = () => {
+ *         deleteOne('likes', { id: record.id, previousData: record })
+ *     }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={handleClick}>Delete</div>;
+ * };
+ *
+ * @example // set params when calling the hook
+ *
+ * import { useDelete, useRecordContext } from 'react-admin';
+ *
+ * const DeleteButton = () => {
+ *     const record = useRecordContext();
+ *     const [deleteOne, { isPending, error }] = useDelete('likes', { id: record.id, previousData: record });
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={() => deleteOne()}>Delete</button>;
+ * };
+ *
+ * @example // TypeScript
+ * const [delete, { data }] = useDelete<Product>('products', { id, previousData: product });
+ *                    \-- data is Product
+ */
+export declare const useDelete: <RecordType extends RaRecord = any, MutationError = unknown>(resource?: string, params?: Partial<DeleteParams<RecordType>>, options?: UseDeleteOptions<RecordType, MutationError>) => UseDeleteResult<RecordType, MutationError>;
+export interface UseDeleteMutateParams<RecordType extends RaRecord = any> {
+    resource?: string;
+    id?: RecordType['id'];
+    data?: Partial<RecordType>;
+    previousData?: any;
+    meta?: any;
+}
+export type UseDeleteOptions<RecordType extends RaRecord = any, MutationError = unknown> = Omit<UseMutationOptions<RecordType, MutationError, Partial<UseDeleteMutateParams<RecordType>>>, 'mutationFn'> & {
+    mutationMode?: MutationMode;
+    returnPromise?: boolean;
+};
+export type UseDeleteResult<RecordType extends RaRecord = any, MutationError = unknown, TReturnPromise extends boolean = boolean> = [
+    (resource?: string, params?: Partial<DeleteParams<RecordType>>, options?: MutateOptions<RecordType | undefined, MutationError, Partial<UseDeleteMutateParams<RecordType>>, unknown> & {
+        mutationMode?: MutationMode;
+        returnPromise?: TReturnPromise;
+    }) => Promise<TReturnPromise extends true ? RecordType | undefined : void>,
+    UseMutationResult<RecordType | undefined, MutationError, Partial<DeleteParams<RecordType> & {
+        resource?: string;
+    }>, unknown> & {
+        isLoading: boolean;
+    }
+];

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

@@ -0,0 +1,171 @@
+import { useQueryClient, } from '@tanstack/react-query';
+import { useDataProvider } from './useDataProvider';
+import { useMutationWithMutationMode, } from './useMutationWithMutationMode';
+import { useEvent } from '../util';
+/**
+ * Get a callback to call the dataProvider.delete() method, the result and the loading state.
+ *
+ * @param {string} resource
+ * @param {Params} params The delete parameters { id, previousData }
+ * @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.id The resource identifier, e.g. 123
+ * @prop params.previousData The record before the update is applied
+ *
+ * @returns The current mutation state. Destructure as [deleteOne, { data, error, isPending }].
+ *
+ * The return value updates according to the request state:
+ *
+ * - initial: [deleteOne, { isPending: false, isIdle: true }]
+ * - start:   [deleteOne, { isPending: true }]
+ * - success: [deleteOne, { data: [data from response], isPending: false, isSuccess: true }]
+ * - error:   [deleteOne, { error: [error from response], isPending: false, isError: true }]
+ *
+ * The deleteOne() function must be called with a resource and a parameter object: deleteOne(resource, { id, previousData, 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 deleteOne callback
+ *
+ * import { useDelete, useRecordContext } from 'react-admin';
+ *
+ * const DeleteButton = () => {
+ *     const record = useRecordContext();
+ *     const [deleteOne, { isPending, error }] = useDelete();
+ *     const handleClick = () => {
+ *         deleteOne('likes', { id: record.id, previousData: record })
+ *     }
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={handleClick}>Delete</div>;
+ * };
+ *
+ * @example // set params when calling the hook
+ *
+ * import { useDelete, useRecordContext } from 'react-admin';
+ *
+ * const DeleteButton = () => {
+ *     const record = useRecordContext();
+ *     const [deleteOne, { isPending, error }] = useDelete('likes', { id: record.id, previousData: record });
+ *     if (error) { return <p>ERROR</p>; }
+ *     return <button disabled={isPending} onClick={() => deleteOne()}>Delete</button>;
+ * };
+ *
+ * @example // TypeScript
+ * const [delete, { data }] = useDelete<Product>('products', { id, previousData: product });
+ *                    \-- data is Product
+ */
+export const useDelete = (resource, params = {}, options = {}) => {
+    const dataProvider = useDataProvider();
+    const queryClient = useQueryClient();
+    const { mutationMode = 'pessimistic', onSettled, ...mutationOptions } = options;
+    const [mutate, mutationResult] = useMutationWithMutationMode({ resource, ...params }, {
+        ...mutationOptions,
+        mutationKey: [resource, 'delete', params],
+        mutationMode,
+        mutationFn: ({ resource, ...params }) => {
+            if (resource == null) {
+                throw new Error('useDelete mutation requires a resource');
+            }
+            if (params.id == null) {
+                throw new Error('useDelete mutation requires a non-empty id');
+            }
+            return dataProvider.delete(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;
+                const index = old.findIndex(
+                // eslint-disable-next-line eqeqeq
+                record => record.id == params.id);
+                if (index === -1) {
+                    return old;
+                }
+                return [...old.slice(0, index), ...old.slice(index + 1)];
+            };
+            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
+                    ? {
+                        data: newCollection,
+                        total: res.total ? res.total - 1 : undefined,
+                        pageInfo: res.pageInfo,
+                    }
+                    : 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 - 1
+                                    : undefined,
+                                pageInfo: page.pageInfo,
+                            }
+                            : 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;
+                return recordWasFound
+                    ? {
+                        ...res,
+                        data: newCollection,
+                        total: res.total - 1,
+                    }
+                    : res;
+            }, { updatedAt });
+            return params.previousData;
+        },
+        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 deleteOne = useEvent((callTimeResource = resource, callTimeParams = {}, callTimeOptions = {}) => {
+        return mutate({
+            resource: callTimeResource,
+            ...callTimeParams,
+        }, callTimeOptions);
+    });
+    return [deleteOne, mutationResult];
+};

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

@@ -0,0 +1,81 @@
+import { type UseMutationOptions, type UseMutationResult, type MutateOptions } from '@tanstack/react-query';
+import type { RaRecord, DeleteManyParams, MutationMode } from '../types';
+/**
+ * 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 declare const useDeleteMany: <RecordType extends RaRecord = any, MutationError = unknown>(resource?: string, params?: Partial<DeleteManyParams<RecordType>>, options?: UseDeleteManyOptions<RecordType, MutationError>) => UseDeleteManyResult<RecordType, MutationError>;
+export interface UseDeleteManyMutateParams<RecordType extends RaRecord = any> {
+    resource?: string;
+    ids?: Array<RecordType['id']>;
+    meta?: any;
+}
+export type UseDeleteManyOptions<RecordType extends RaRecord = any, MutationError = unknown, TReturnPromise extends boolean = boolean> = Omit<UseMutationOptions<Array<RecordType['id']> | undefined, MutationError, Partial<UseDeleteManyMutateParams<RecordType>>>, 'mutationFn'> & {
+    mutationMode?: MutationMode;
+    returnPromise?: TReturnPromise;
+};
+export type UseDeleteManyResult<RecordType extends RaRecord = any, MutationError = unknown, TReturnPromise extends boolean = boolean> = [
+    (resource?: string, params?: Partial<DeleteManyParams<RecordType>>, options?: MutateOptions<Array<RecordType['id']> | undefined, MutationError, Partial<UseDeleteManyMutateParams<RecordType>>, unknown> & {
+        mutationMode?: MutationMode;
+        returnPromise?: TReturnPromise;
+    }) => Promise<TReturnPromise extends true ? Array<RecordType['id']> | undefined : void>,
+    UseMutationResult<Array<RecordType['id']> | undefined, MutationError, Partial<DeleteManyParams<RecordType> & {
+        resource?: string;
+    }>, unknown> & {
+        isLoading: boolean;
+    }
+];