@strato-admin/core 0.1.0 → 0.3.0

package/dist/ra-core/src/auth/useLogout.js

@@ -0,0 +1,117 @@
+import { useCallback, useEffect, useRef } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+import useAuthProvider, { defaultAuthParams } from './useAuthProvider';
+import { useResetStore } from '../store';
+import { useBasename, useLocation, useNavigate } from '../routing';
+import { removeDoubleSlashes } from '../routing/useCreatePath';
+/**
+ * Get a callback for calling the authProvider.logout() method,
+ * redirect to the login page, and clear the store.
+ *
+ * @see useAuthProvider
+ *
+ * @returns {Function} logout callback
+ *
+ * @example
+ *
+ * import { useLogout } from 'react-admin';
+ *
+ * const LogoutButton = () => {
+ *     const logout = useLogout();
+ *     const handleClick = () => logout();
+ *     return <button onClick={handleClick}>Logout</button>;
+ * }
+ */
+const useLogout = () => {
+    const authProvider = useAuthProvider();
+    const queryClient = useQueryClient();
+    const resetStore = useResetStore();
+    const navigate = useNavigate();
+    const location = useLocation();
+    const locationRef = useRef(location);
+    const basename = useBasename();
+    const loginUrl = removeDoubleSlashes(`${basename}/${defaultAuthParams.loginUrl}`);
+    /*
+     * We need the current location to pass in the router state
+     * so that the login hook knows where to redirect to as next route after login.
+     *
+     * But if we used the location from useLocation as a dependency of the logout
+     * function, it would be rebuilt each time the user changes location.
+     * Consequently, that would force a rerender of all components using this hook
+     * upon navigation (CoreAdminRouter for example).
+     *
+     * To avoid that, we store the location in a ref.
+     */
+    useEffect(() => {
+        locationRef.current = location;
+    }, [location]);
+    const logout = useCallback((params = {}, redirectFromCaller, redirectToCurrentLocationAfterLogin = true) => {
+        if (authProvider) {
+            return authProvider.logout(params).then(redirectFromLogout => {
+                if (redirectFromLogout === false ||
+                    redirectFromCaller === false) {
+                    resetStore();
+                    queryClient.clear();
+                    // do not redirect
+                    return;
+                }
+                const finalRedirectTo = redirectFromCaller || redirectFromLogout || loginUrl;
+                if (finalRedirectTo?.startsWith('http')) {
+                    // absolute link (e.g. https://my.oidc.server/login)
+                    resetStore();
+                    queryClient.clear();
+                    window.location.href = finalRedirectTo;
+                    return finalRedirectTo;
+                }
+                // redirectTo is an internal location that may contain a query string, e.g. '/login?foo=bar'
+                // we must split it to pass a structured location to navigate()
+                const redirectToParts = finalRedirectTo.split('?');
+                const newLocation = {
+                    pathname: redirectToParts[0],
+                };
+                let newLocationOptions = {};
+                if (redirectToCurrentLocationAfterLogin &&
+                    locationRef.current &&
+                    locationRef.current.pathname) {
+                    newLocationOptions = {
+                        state: {
+                            nextPathname: locationRef.current.pathname,
+                            nextSearch: locationRef.current.search,
+                        },
+                    };
+                }
+                if (redirectToParts[1]) {
+                    newLocation.search = redirectToParts[1];
+                }
+                // We need to navigate and reset the store after a litte delay to avoid a race condition
+                // between the store reset and the navigation.
+                //
+                // This would only happen when the `authProvider.getPermissions` method returns
+                // a resolved promise with no delay: If the store was reset before the navigation,
+                // the `usePermissions` query would reset, causing the `CoreAdminRoutes` component to
+                // rerender the `LogoutOnMount` component leading to an infinite loop.
+                setTimeout(() => {
+                    navigate(newLocation, newLocationOptions);
+                    resetStore();
+                    queryClient.clear();
+                }, 0);
+                return redirectFromLogout;
+            });
+        }
+        else {
+            navigate({
+                pathname: loginUrl,
+            }, {
+                state: {
+                    nextPathname: locationRef.current &&
+                        locationRef.current.pathname,
+                },
+            });
+            resetStore();
+            queryClient.clear();
+            return Promise.resolve();
+        }
+    }, [authProvider, resetStore, loginUrl, queryClient, navigate]);
+    return logout;
+};
+export default useLogout;

package/dist/ra-core/src/auth/useLogoutIfAccessDenied.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Returns a callback used to call the authProvider.checkError() method
+ * and an error from the dataProvider. If the authProvider rejects the call,
+ * the hook logs the user out and shows a logged out notification.
+ *
+ * Used in the useDataProvider hook to check for access denied responses
+ * (e.g. 401 or 403 responses) and trigger a logout.
+ *
+ * @see useLogout
+ * @see useDataProvider
+ *
+ * @returns {Function} logoutIfAccessDenied callback
+ *
+ * @example
+ *
+ * import { useLogoutIfAccessDenied, useNotify, DataProviderContext } from 'react-admin';
+ *
+ * const FetchRestrictedResource = () => {
+ *     const dataProvider = useContext(DataProviderContext);
+ *     const logoutIfAccessDenied = useLogoutIfAccessDenied();
+ *     const notify = useNotify()
+ *     useEffect(() => {
+ *         dataProvider.getOne('secret', { id: 123 })
+ *             .catch(error => {
+ *                  logoutIfAccessDenied(error);
+ *                  notify('server error',  { type: 'error' });
+ *              })
+ *     }, []);
+ *     // ...
+ * }
+ */
+declare const useLogoutIfAccessDenied: () => LogoutIfAccessDenied;
+/**
+ * Call the authProvider.authError() method, using the error passed as argument.
+ * If the authProvider rejects the call, logs the user out and shows a logged out notification.
+ *
+ * @param {Error} error An Error object (usually returned by the dataProvider)
+ *
+ * @return {Promise} Resolved to true if there was a logout, false otherwise
+ */
+type LogoutIfAccessDenied = (error?: any) => Promise<boolean>;
+export default useLogoutIfAccessDenied;

package/dist/ra-core/src/auth/useLogoutIfAccessDenied.js

@@ -0,0 +1,111 @@
+import { useCallback } from 'react';
+import useAuthProvider from './useAuthProvider';
+import useLogout from './useLogout';
+import { useNotify } from '../notification';
+import { useNavigate } from '../routing/useNavigate';
+let timer;
+/**
+ * Returns a callback used to call the authProvider.checkError() method
+ * and an error from the dataProvider. If the authProvider rejects the call,
+ * the hook logs the user out and shows a logged out notification.
+ *
+ * Used in the useDataProvider hook to check for access denied responses
+ * (e.g. 401 or 403 responses) and trigger a logout.
+ *
+ * @see useLogout
+ * @see useDataProvider
+ *
+ * @returns {Function} logoutIfAccessDenied callback
+ *
+ * @example
+ *
+ * import { useLogoutIfAccessDenied, useNotify, DataProviderContext } from 'react-admin';
+ *
+ * const FetchRestrictedResource = () => {
+ *     const dataProvider = useContext(DataProviderContext);
+ *     const logoutIfAccessDenied = useLogoutIfAccessDenied();
+ *     const notify = useNotify()
+ *     useEffect(() => {
+ *         dataProvider.getOne('secret', { id: 123 })
+ *             .catch(error => {
+ *                  logoutIfAccessDenied(error);
+ *                  notify('server error',  { type: 'error' });
+ *              })
+ *     }, []);
+ *     // ...
+ * }
+ */
+const useLogoutIfAccessDenied = () => {
+    const authProvider = useAuthProvider();
+    const logout = useLogout();
+    const notify = useNotify();
+    const navigate = useNavigate();
+    const handleRedirect = useCallback((url) => {
+        if (url.startsWith('http')) {
+            window.location.href = url;
+        }
+        else {
+            navigate(url);
+        }
+    }, [navigate]);
+    const logoutIfAccessDenied = useCallback(async (errorFromCheckAuth) => {
+        if (!authProvider) {
+            return logoutIfAccessDeniedWithoutProvider();
+        }
+        try {
+            await authProvider.checkError(errorFromCheckAuth);
+            return false;
+        }
+        catch (errorFromCheckError) {
+            const logoutUser = errorFromCheckError?.logoutUser ?? true;
+            // manual debounce
+            if (timer) {
+                return true; // side effects already triggered in this tick, exit
+            }
+            timer = setTimeout(() => {
+                timer = undefined;
+            }, 0);
+            const redirectTo = errorFromCheckError &&
+                errorFromCheckError.redirectTo != null
+                ? errorFromCheckError.redirectTo
+                : errorFromCheckAuth && errorFromCheckAuth.redirectTo
+                    ? errorFromCheckAuth.redirectTo
+                    : undefined;
+            const shouldNotify = !((errorFromCheckError &&
+                errorFromCheckError.message === false) ||
+                (errorFromCheckAuth &&
+                    errorFromCheckAuth.message === false) ||
+                redirectTo?.startsWith('http'));
+            if (shouldNotify) {
+                try {
+                    // notify only if not yet logged out
+                    await authProvider.checkAuth({});
+                    if (logoutUser) {
+                        notify(getErrorMessage(errorFromCheckError, "strato.notification.logged_out'), { type: 'error' });
+                    }
+                    else {
+                        notify(getErrorMessage(errorFromCheckError, "strato.notification.not_authorized'), { type: 'error' });
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+            if (logoutUser) {
+                logout({}, redirectTo);
+            }
+            else if (redirectTo) {
+                handleRedirect(redirectTo);
+            }
+            return true;
+        }
+    }, [authProvider, logout, notify, handleRedirect]);
+    return logoutIfAccessDenied;
+};
+const logoutIfAccessDeniedWithoutProvider = async () => false;
+const getErrorMessage = (error, defaultMessage) => typeof error === 'string'
+    ? error
+    : typeof error === 'undefined' || !error.message
+        ? defaultMessage
+        : error.message;
+export default useLogoutIfAccessDenied;

package/dist/ra-core/src/auth/usePermissions.d.ts

@@ -0,0 +1,41 @@
+import { QueryObserverResult, UseQueryOptions } from '@tanstack/react-query';
+/**
+ * Hook for getting user permissions
+ *
+ * Calls the authProvider.getPermissions() method using react-query.
+ * If the authProvider returns a rejected promise, returns empty permissions.
+ *
+ * The return value updates according to the request state:
+ *
+ * - start: { isPending: true }
+ * - success: { permissions: [any], isPending: false }
+ * - error: { error: [error from provider], isPending: false }
+ *
+ * Useful to enable features based on user permissions
+ *
+ * @param {Object} params Any params you want to pass to the authProvider
+ *
+ * @returns The current auth check state. Destructure as { permissions, error, isPending, refetch }.
+ *
+ * @example
+ *     import { usePermissions } from 'react-admin';
+ *
+ *     const PostDetail = () => {
+ *         const { isPending, permissions } = usePermissions();
+ *         if (!isPending && permissions == 'editor') {
+ *             return <PostEdit />
+ *         } else {
+ *             return <PostShow />
+ *         }
+ *     };
+ */
+declare const usePermissions: <PermissionsType = any, ErrorType = Error>(params?: {}, queryParams?: UsePermissionsOptions<PermissionsType, ErrorType>) => UsePermissionsResult<PermissionsType, ErrorType>;
+export default usePermissions;
+export interface UsePermissionsOptions<PermissionsType = any, ErrorType = Error> extends Omit<UseQueryOptions<PermissionsType, ErrorType>, 'queryKey' | 'queryFn'> {
+    onSuccess?: (data: PermissionsType) => void;
+    onError?: (err: ErrorType) => void;
+    onSettled?: (data?: PermissionsType, error?: ErrorType | null) => void;
+}
+export type UsePermissionsResult<PermissionsType = any, ErrorType = Error> = QueryObserverResult<PermissionsType, ErrorType> & {
+    permissions: PermissionsType | undefined;
+};

package/dist/ra-core/src/auth/usePermissions.js

@@ -0,0 +1,123 @@
+import { useEffect, useMemo } from 'react';
+import { useQuery, } from '@tanstack/react-query';
+import useAuthProvider from './useAuthProvider';
+import useLogoutIfAccessDenied from './useLogoutIfAccessDenied';
+import { useEvent } from '../util';
+const emptyParams = {};
+/**
+ * Hook for getting user permissions
+ *
+ * Calls the authProvider.getPermissions() method using react-query.
+ * If the authProvider returns a rejected promise, returns empty permissions.
+ *
+ * The return value updates according to the request state:
+ *
+ * - start: { isPending: true }
+ * - success: { permissions: [any], isPending: false }
+ * - error: { error: [error from provider], isPending: false }
+ *
+ * Useful to enable features based on user permissions
+ *
+ * @param {Object} params Any params you want to pass to the authProvider
+ *
+ * @returns The current auth check state. Destructure as { permissions, error, isPending, refetch }.
+ *
+ * @example
+ *     import { usePermissions } from 'react-admin';
+ *
+ *     const PostDetail = () => {
+ *         const { isPending, permissions } = usePermissions();
+ *         if (!isPending && permissions == 'editor') {
+ *             return <PostEdit />
+ *         } else {
+ *             return <PostShow />
+ *         }
+ *     };
+ */
+const usePermissions = (params = emptyParams, queryParams = {
+    staleTime: 5 * 60 * 1000,
+}) => {
+    const authProvider = useAuthProvider();
+    const logoutIfAccessDenied = useLogoutIfAccessDenied();
+    const { onSuccess, onError, onSettled, ...queryOptions } = queryParams ?? {};
+    const queryResult = useQuery({
+        queryKey: ['auth', 'getPermissions', params],
+        queryFn: async ({ signal }) => {
+            if (!authProvider || !authProvider.getPermissions) {
+                return [];
+            }
+            const permissions = await authProvider.getPermissions({
+                ...params,
+                signal,
+            });
+            return permissions ?? null;
+        },
+        ...queryOptions,
+    });
+    const onSuccessEvent = useEvent(onSuccess ?? noop);
+    const onSettledEvent = useEvent(onSettled ?? noop);
+    const onErrorEvent = useEvent(onError ??
+        ((error) => {
+            if (process.env.NODE_ENV === 'development') {
+                console.error(error);
+            }
+            logoutIfAccessDenied(error);
+        }));
+    useEffect(() => {
+        if (queryResult.data === undefined || queryResult.isFetching)
+            return;
+        onSuccessEvent(queryResult.data);
+    }, [onSuccessEvent, queryResult.data, queryResult.isFetching]);
+    useEffect(() => {
+        if (queryResult.error == null || queryResult.isFetching)
+            return;
+        onErrorEvent(queryResult.error);
+    }, [onErrorEvent, queryResult.error, queryResult.isFetching]);
+    useEffect(() => {
+        if (queryResult.status === 'pending' || queryResult.isFetching)
+            return;
+        onSettledEvent(queryResult.data, queryResult.error);
+    }, [
+        onSettledEvent,
+        queryResult.data,
+        queryResult.error,
+        queryResult.status,
+        queryResult.isFetching,
+    ]);
+    const result = useMemo(() => ({
+        ...queryResult,
+        permissions: queryResult.data,
+    }), [queryResult]);
+    return !authProvider || !authProvider.getPermissions
+        ? fakeQueryResult
+        : result;
+};
+export default usePermissions;
+const noop = () => { };
+const fakeQueryResult = {
+    permissions: undefined,
+    data: undefined,
+    dataUpdatedAt: 0,
+    error: null,
+    errorUpdatedAt: 0,
+    errorUpdateCount: 0,
+    failureCount: 0,
+    failureReason: null,
+    fetchStatus: 'idle',
+    isError: false,
+    isInitialLoading: false,
+    isLoading: false,
+    isLoadingError: false,
+    isFetched: true,
+    isFetchedAfterMount: true,
+    isFetching: false,
+    isPaused: false,
+    isPlaceholderData: false,
+    isPending: false,
+    isRefetchError: false,
+    isRefetching: false,
+    isStale: false,
+    isSuccess: true,
+    status: 'success',
+    refetch: () => Promise.resolve(fakeQueryResult),
+};

package/dist/ra-core/src/auth/useRequireAccess.d.ts

@@ -0,0 +1,140 @@
+import { RaRecord } from '../types';
+import { UseCanAccessOptions, UseCanAccessResult } from './useCanAccess';
+/**
+ * A hook that calls the authProvider.canAccess() method for a provided resource and action (and optionally a record).
+ * It redirects to the /access-denied page if the user doesn't have the required permissions.
+ * It redirects to the /authentication-error page if the authProvider.canAccess throws an error.
+ *
+ * The return value updates according to the request state:
+ *
+ * - start: { isPending: true }
+ * - success: { isPending: false }
+ * - error: { error: [error from provider], isPending: false }
+ *
+ * Useful to enable or disable features based on users permissions.
+ *
+ * @param {Object} params Any params you want to pass to the authProvider
+ * @param {string} params.resource The resource to check access for
+ * @param {string} params.action The action to check access for
+ * @param {Object} params.record Optional. The record to check access for
+ *
+ * @returns Return the react-query result.
+ *
+ * @example
+ *     import { useRequireAccess } from 'react-admin';
+ *
+ *     const PostDetail = () => {
+ *         const { isPending } = useRequireAccess({
+ *             resource: 'posts',
+ *             action: 'read',
+ *         });
+ *         if (isPending) {
+ *             return null;
+ *         }
+ *
+ *         return <PostEdit />;
+ *     };
+ */
+export declare const useRequireAccess: <RecordType extends RaRecord | Omit<RaRecord, "id"> = RaRecord, ErrorType extends Error = Error>(params: UseRequireAccessOptions<RecordType, ErrorType>) => {
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: ErrorType | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<boolean, ErrorType>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<boolean>;
+} | {
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: ErrorType | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<boolean, ErrorType>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<boolean>;
+} | {
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: ErrorType | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<boolean, ErrorType>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<boolean>;
+} | {
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: ErrorType | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<boolean, ErrorType>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<boolean>;
+};
+export type UseRequireAccessOptions<RecordType extends RaRecord | Omit<RaRecord, 'id'> = RaRecord, ErrorType extends Error = Error> = UseCanAccessOptions<RecordType, ErrorType>;
+export type UseRequireAccessResult<ErrorType extends Error = Error> = Omit<UseCanAccessResult<ErrorType>, 'canAccess' | 'data'>;

package/dist/ra-core/src/auth/useRequireAccess.js

@@ -0,0 +1,56 @@
+import { useEffect } from 'react';
+import { useCanAccess, } from './useCanAccess';
+import { useBasename, useNavigate } from '../routing';
+/**
+ * A hook that calls the authProvider.canAccess() method for a provided resource and action (and optionally a record).
+ * It redirects to the /access-denied page if the user doesn't have the required permissions.
+ * It redirects to the /authentication-error page if the authProvider.canAccess throws an error.
+ *
+ * The return value updates according to the request state:
+ *
+ * - start: { isPending: true }
+ * - success: { isPending: false }
+ * - error: { error: [error from provider], isPending: false }
+ *
+ * Useful to enable or disable features based on users permissions.
+ *
+ * @param {Object} params Any params you want to pass to the authProvider
+ * @param {string} params.resource The resource to check access for
+ * @param {string} params.action The action to check access for
+ * @param {Object} params.record Optional. The record to check access for
+ *
+ * @returns Return the react-query result.
+ *
+ * @example
+ *     import { useRequireAccess } from 'react-admin';
+ *
+ *     const PostDetail = () => {
+ *         const { isPending } = useRequireAccess({
+ *             resource: 'posts',
+ *             action: 'read',
+ *         });
+ *         if (isPending) {
+ *             return null;
+ *         }
+ *
+ *         return <PostEdit />;
+ *     };
+ */
+export const useRequireAccess = (params) => {
+    const { canAccess, data, error, ...rest } = useCanAccess(params);
+    const navigate = useNavigate();
+    const basename = useBasename();
+    useEffect(() => {
+        if (rest.isPending)
+            return;
+        if (canAccess === false) {
+            navigate(`${basename}/access-denied`);
+        }
+    }, [basename, canAccess, navigate, rest.isPending]);
+    useEffect(() => {
+        if (error) {
+            navigate(`${basename}/authentication-error`);
+        }
+    }, [basename, navigate, error]);
+    return rest;
+};

package/dist/ra-core/src/controller/button/index.d.ts

@@ -0,0 +1,7 @@
+import useDeleteWithUndoController from './useDeleteWithUndoController';
+import useDeleteWithConfirmController from './useDeleteWithConfirmController';
+export { useDeleteWithUndoController, useDeleteWithConfirmController };
+export * from './useDeleteController';
+export * from './useBulkDeleteController';
+export * from './useUpdateController';
+export * from './useBulkUpdateController';

package/dist/ra-core/src/controller/button/index.js

@@ -0,0 +1,7 @@
+import useDeleteWithUndoController from './useDeleteWithUndoController';
+import useDeleteWithConfirmController from './useDeleteWithConfirmController';
+export { useDeleteWithUndoController, useDeleteWithConfirmController };
+export * from './useDeleteController';
+export * from './useBulkDeleteController';
+export * from './useUpdateController';
+export * from './useBulkUpdateController';

package/dist/ra-core/src/controller/button/useBulkDeleteController.d.ts

@@ -0,0 +1,14 @@
+import { UseDeleteManyOptions } from '../../dataProvider/useDeleteMany';
+import { RaRecord, MutationMode } from '../../types';
+export declare const useBulkDeleteController: <RecordType extends RaRecord = any, ErrorType = Error>(props: UseBulkDeleteControllerParams<RecordType, ErrorType>) => UseBulkDeleteControllerReturn;
+export interface UseBulkDeleteControllerParams<RecordType extends RaRecord = any, MutationOptionsError = unknown> {
+    mutationMode?: MutationMode;
+    mutationOptions?: UseDeleteManyOptions<RecordType, MutationOptionsError>;
+    resource?: string;
+    successMessage?: string;
+}
+export interface UseBulkDeleteControllerReturn {
+    isLoading: boolean;
+    isPending: boolean;
+    handleDelete: () => void;
+}