@strato-admin/core 0.1.0 → 0.3.0

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

@@ -0,0 +1,27 @@
+export * from './CoreAdmin';
+export * from './CoreAdminContext';
+export * from './CoreAdminRoutes';
+export * from './CoreAdminUI';
+export * from './CustomRoutes';
+export * from './DefaultTitleContext';
+export * from './HasDashboardContext';
+export * from './IsOffline';
+export * from './NavigateToFirstResource';
+export * from './OptionalResourceContextProvider';
+export * from './Resource';
+export * from './ResourceContext';
+export * from './ResourceContextProvider';
+export * from './ResourceDefinitionContext';
+export * from './SourceContext';
+export * from './UserMenuContext';
+export * from './UserMenuContextProvider';
+export * from './useFirstResourceWithListAccess';
+export * from './useGetResourceLabel';
+export * from './useGetRecordRepresentation';
+export * from './useIsOffline';
+export * from './useResourceDefinitionContext';
+export * from './useResourceContext';
+export * from './useResourceDefinition';
+export * from './useResourceDefinitions';
+export * from './useUserMenu';
+export * from './useWrappedSource';

package/dist/ra-core/src/core/useConfigureAdminRouterFromChildren.d.ts

@@ -0,0 +1,34 @@
+import { ReactElement, ReactNode } from 'react';
+import { AdminChildren, ResourceDefinition, ResourceProps } from '../types';
+/**
+ * This hook inspects the CoreAdminRouter children and returns them separated in three groups:
+ * - Custom routes without layout
+ * - Custom routes with layout
+ * - Resources
+ *
+ * It also returns a status:
+ * - loading: still loading children from a function child
+ * - empty: no resources were provided among children
+ * - ready: admin is ready to be rendered
+ *
+ * @example
+ * const {
+ *    customRoutesWithLayout,
+ *    customRoutesWithoutLayout,
+ *    resources,
+ *    status,
+ * } = useConfigureAdminRouterFromChildren(children);
+ */
+export declare const useConfigureAdminRouterFromChildren: (children: AdminChildren) => RoutesAndResources & {
+    status: AdminRouterStatus;
+};
+type RoutesAndResources = {
+    customRoutesWithLayout: ReactNode[];
+    customRoutesWithoutLayout: ReactNode[];
+    resources: (ReactElement & ResourceWithRegisterFunction)[];
+};
+type ResourceWithRegisterFunction = {
+    registerResource: (props: ResourceProps, permissions: any) => ResourceDefinition;
+};
+type AdminRouterStatus = 'loading' | 'empty' | 'ready';
+export {};

package/dist/ra-core/src/core/useConfigureAdminRouterFromChildren.js

@@ -0,0 +1,227 @@
+import * as React from 'react';
+import { Children, Fragment, useCallback, useEffect, useState, } from 'react';
+import useLogout from '../auth/useLogout';
+import usePermissions from '../auth/usePermissions';
+import { useResourceDefinitionContext } from './useResourceDefinitionContext';
+/**
+ * This hook inspects the CoreAdminRouter children and returns them separated in three groups:
+ * - Custom routes without layout
+ * - Custom routes with layout
+ * - Resources
+ *
+ * It also returns a status:
+ * - loading: still loading children from a function child
+ * - empty: no resources were provided among children
+ * - ready: admin is ready to be rendered
+ *
+ * @example
+ * const {
+ *    customRoutesWithLayout,
+ *    customRoutesWithoutLayout,
+ *    resources,
+ *    status,
+ * } = useConfigureAdminRouterFromChildren(children);
+ */
+export const useConfigureAdminRouterFromChildren = (children) => {
+    const { permissions, isPending } = usePermissions();
+    // Whenever children are updated, update our custom routes and resources
+    const [routesAndResources, status] = useRoutesAndResourcesFromChildren(children, permissions, isPending);
+    // Whenever the resources change, we must ensure they're all registered
+    useRegisterResources(routesAndResources.resources, permissions);
+    return {
+        customRoutesWithLayout: routesAndResources.customRoutesWithLayout,
+        customRoutesWithoutLayout: routesAndResources.customRoutesWithoutLayout,
+        status,
+        resources: routesAndResources.resources,
+    };
+};
+/**
+ * A hook that determine the routes and resources from React nodes and permissions.
+ * Returns a tuple with the routes and resources as a single object, and the status.
+ * @param children React nodes to inspect
+ * @param permissions The permissions
+ */
+const useRoutesAndResourcesFromChildren = (children, permissions, isLoading) => {
+    // Gather custom routes and resources that were declared as direct children of CoreAdminRouter
+    // e.g. Not returned from the child function (if any)
+    // We need to know right away whether some resources were declared to correctly
+    // initialize the status at the next stop
+    const doLogout = useLogout();
+    const [routesAndResources, setRoutesAndResources, mergeRoutesAndResources] = useRoutesAndResourcesState(getRoutesAndResourceFromNodes(children));
+    const [status, setStatus] = useState(() => getStatus({
+        children,
+        ...routesAndResources,
+    }));
+    if (!status) {
+        throw new Error('Status should be defined');
+    }
+    useEffect(() => {
+        const resolveChildFunction = async (childFunc) => {
+            try {
+                const childrenFuncResult = childFunc(permissions);
+                if (childrenFuncResult?.then) {
+                    childrenFuncResult.then(resolvedChildren => {
+                        mergeRoutesAndResources(getRoutesAndResourceFromNodes(resolvedChildren));
+                        setStatus('ready');
+                    });
+                }
+                else {
+                    mergeRoutesAndResources(getRoutesAndResourceFromNodes(childrenFuncResult));
+                    setStatus('ready');
+                }
+            }
+            catch (error) {
+                console.error(error);
+                doLogout();
+            }
+        };
+        const updateFromChildren = async () => {
+            const functionChild = getSingleChildFunction(children);
+            const newRoutesAndResources = getRoutesAndResourceFromNodes(children);
+            setRoutesAndResources(newRoutesAndResources);
+            setStatus(functionChild
+                ? 'loading'
+                : newRoutesAndResources.resources.length > 0 ||
+                    newRoutesAndResources.customRoutesWithLayout.length >
+                        0 ||
+                    newRoutesAndResources.customRoutesWithoutLayout.length >
+                        0
+                    ? 'ready'
+                    : 'empty');
+            if (functionChild) {
+                resolveChildFunction(functionChild);
+            }
+        };
+        if (!isLoading) {
+            updateFromChildren();
+        }
+    }, [
+        children,
+        doLogout,
+        isLoading,
+        mergeRoutesAndResources,
+        permissions,
+        setRoutesAndResources,
+        setStatus,
+    ]);
+    return [routesAndResources, status];
+};
+/*
+ * A hook that store the routes and resources just like setState but also provides an additional function
+ * to merge new routes and resources with the existing ones.
+ */
+const useRoutesAndResourcesState = (initialState) => {
+    const [routesAndResources, setRoutesAndResources] = useState(initialState);
+    const mergeRoutesAndResources = useCallback((newRoutesAndResources) => {
+        setRoutesAndResources(previous => ({
+            customRoutesWithLayout: previous.customRoutesWithLayout.concat(newRoutesAndResources.customRoutesWithLayout),
+            customRoutesWithoutLayout: previous.customRoutesWithoutLayout.concat(newRoutesAndResources.customRoutesWithoutLayout),
+            resources: previous.resources.concat(newRoutesAndResources.resources),
+        }));
+    }, []);
+    return [routesAndResources, setRoutesAndResources, mergeRoutesAndResources];
+};
+/**
+ * A hook that register resources and unregister them when the calling component is unmounted.
+ * @param resources: An array of Resource elements
+ * @param permissions: The permissions
+ */
+const useRegisterResources = (resources, permissions) => {
+    const { register, unregister } = useResourceDefinitionContext();
+    useEffect(() => {
+        resources.forEach(resource => {
+            if (typeof resource.type.registerResource === 'function') {
+                const definition = resource.type.registerResource(resource.props, permissions);
+                register(definition);
+            }
+            else {
+                throw new Error('When using a custom Resource element, it must have a static registerResource method accepting its props and returning a ResourceDefinition');
+            }
+        });
+        return () => {
+            resources.forEach(resource => {
+                if (typeof resource.type.registerResource === 'function') {
+                    const definition = resource.type.registerResource(resource.props, permissions);
+                    unregister(definition);
+                }
+                else {
+                    throw new Error('When using a custom Resource element, it must have a static registerResource method accepting its props and returning a ResourceDefinition');
+                }
+            });
+        };
+    }, [permissions, register, resources, unregister]);
+};
+const getStatus = ({ children, resources, customRoutesWithLayout, customRoutesWithoutLayout, }) => {
+    return getSingleChildFunction(children)
+        ? 'loading'
+        : resources.length > 0 ||
+            customRoutesWithLayout.length > 0 ||
+            customRoutesWithoutLayout.length > 0
+            ? 'ready'
+            : 'empty';
+};
+/**
+ * Inspect the children of a CoreAdminRouter to see if one of them is a function.
+ * Throws an error if there are more than one function child.
+ * Returns the function child if one was provided, or null otherwise.
+ */
+const getSingleChildFunction = (children) => {
+    const childrenArray = Array.isArray(children) ? children : [children];
+    const functionChildren = childrenArray.filter(child => typeof child === 'function');
+    if (functionChildren.length > 1) {
+        throw new Error('You can only provide one function child to AdminRouter');
+    }
+    if (functionChildren.length === 0) {
+        return null;
+    }
+    return functionChildren[0];
+};
+/**
+ * Inspect the children and return an object with the following keys:
+ * - customRoutesWithLayout: an array of the custom routes to render inside the layout
+ * - customRoutesWithoutLayout: an array of custom routes to render outside the layout
+ * - resources: an array of resources elements
+ */
+const getRoutesAndResourceFromNodes = (children) => {
+    const customRoutesWithLayout = [];
+    const customRoutesWithoutLayout = [];
+    const resources = [];
+    if (typeof children === 'function') {
+        return {
+            customRoutesWithLayout: [],
+            customRoutesWithoutLayout: [],
+            resources: [],
+        };
+    }
+    // @ts-ignore
+    Children.forEach(children, element => {
+        if (!React.isValidElement(element)) {
+            // Ignore non-elements. This allows people to more easily inline
+            // conditionals in their route config.
+            return;
+        }
+        if (element.type === Fragment) {
+            const customRoutesFromFragment = getRoutesAndResourceFromNodes(element.props.children);
+            customRoutesWithLayout.push(...customRoutesFromFragment.customRoutesWithLayout);
+            customRoutesWithoutLayout.push(...customRoutesFromFragment.customRoutesWithoutLayout);
+            resources.push(...customRoutesFromFragment.resources);
+        }
+        if (element.type.raName === 'CustomRoutes') {
+            const customRoutesElement = element;
+            if (customRoutesElement.props.noLayout) {
+                customRoutesWithoutLayout.push(customRoutesElement.props.children);
+            }
+            else {
+                customRoutesWithLayout.push(customRoutesElement.props.children);
+            }
+        }
+        else if (element.type.raName === 'Resource') {
+            resources.push(element);
+        }
+    });
+    return {
+        customRoutesWithLayout,
+        customRoutesWithoutLayout,
+        resources,
+    };
+};

package/dist/ra-core/src/core/useFirstResourceWithListAccess.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A hook that returns the first resource for which users have access to the list page.
+ * It calls the `authProvider.canAccess` if available to check the permissions.
+ */
+export declare const useFirstResourceWithListAccess: () => {
+    resource: string | undefined;
+    isPending: boolean;
+};

package/dist/ra-core/src/core/useFirstResourceWithListAccess.js

@@ -0,0 +1,19 @@
+import { useCanAccessResources } from '../auth/useCanAccessResources';
+import { useAuthenticated } from '../auth';
+import { useResourceDefinitions } from './useResourceDefinitions';
+/**
+ * A hook that returns the first resource for which users have access to the list page.
+ * It calls the `authProvider.canAccess` if available to check the permissions.
+ */
+export const useFirstResourceWithListAccess = () => {
+    const { isPending: isPendingAuthenticated } = useAuthenticated();
+    const resources = useResourceDefinitions();
+    const resourcesNames = Object.keys(resources).filter(resource => resources[resource].hasList);
+    const { canAccess, isPending } = useCanAccessResources({
+        action: 'list',
+        resources: resourcesNames,
+        enabled: !isPendingAuthenticated,
+    });
+    const firstResourceWithListAccess = resourcesNames.find(resource => canAccess && canAccess[resource] === true);
+    return { resource: firstResourceWithListAccess, isPending };
+};

package/dist/ra-core/src/core/useGetRecordRepresentation.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+/**
+ * Get the default representation of a record (either a string or a React node)
+ *
+ * @example // No customization
+ * const getRecordRepresentation = useGetRecordRepresentation('posts');
+ * getRecordRepresentation({ id: 1, title: 'Hello' }); // => "#1"
+ *
+ * @example // With <Resource name="posts" recordRepresentation="title" />
+ * const getRecordRepresentation = useGetRecordRepresentation('posts');
+ * getRecordRepresentation({ id: 1, title: 'Hello' }); // => "Hello"
+ */
+export declare const useGetRecordRepresentation: (resource?: string) => ((record: any) => ReactNode);

package/dist/ra-core/src/core/useGetRecordRepresentation.js

@@ -0,0 +1,44 @@
+import * as React from 'react';
+import { useCallback } from 'react';
+import get from 'lodash/get.js';
+import { useResourceDefinition } from './useResourceDefinition';
+/**
+ * Get the default representation of a record (either a string or a React node)
+ *
+ * @example // No customization
+ * const getRecordRepresentation = useGetRecordRepresentation('posts');
+ * getRecordRepresentation({ id: 1, title: 'Hello' }); // => "#1"
+ *
+ * @example // With <Resource name="posts" recordRepresentation="title" />
+ * const getRecordRepresentation = useGetRecordRepresentation('posts');
+ * getRecordRepresentation({ id: 1, title: 'Hello' }); // => "Hello"
+ */
+export const useGetRecordRepresentation = (resource) => {
+    const { recordRepresentation } = useResourceDefinition({ resource });
+    return useCallback(record => {
+        if (!record)
+            return '';
+        if (typeof recordRepresentation === 'function') {
+            return recordRepresentation(record);
+        }
+        if (typeof recordRepresentation === 'string') {
+            return get(record, recordRepresentation);
+        }
+        if (React.isValidElement(recordRepresentation)) {
+            return recordRepresentation;
+        }
+        if (record?.name != null && record?.name !== '') {
+            return record.name;
+        }
+        if (record?.title != null && record?.title !== '') {
+            return record.title;
+        }
+        if (record?.label != null && record?.label !== '') {
+            return record.label;
+        }
+        if (record?.reference != null && record?.reference !== '') {
+            return record.reference;
+        }
+        return `#${record.id}`;
+    }, [recordRepresentation]);
+};

package/dist/ra-core/src/core/useGetResourceLabel.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A hook which returns function to get a translated resource name. It will use the label option of the `Resource` component if it was provided.
+ *
+ * @returns {GetResourceLabel} A function which takes a resource name and an optional number indicating the number of items (used for pluralization) and returns a translated string.
+ * @example
+ * const Menu = () => {
+ *     const resources = useResourceDefinitions();
+ *     const getResourceLabel = useGetResourceLabel();
+ *
+ *     return (
+ *         <ul>
+ *             {Object.keys(resources).map(name => (
+ *                 <li key={name}>
+ *                     {getResourceLabel(name, 2)}
+ *                 </li>
+ *             ))}
+ *         </ul>
+ *     )
+ * }
+ */
+export declare const useGetResourceLabel: () => GetResourceLabel;
+export type GetResourceLabel = (resource: string, count?: number) => string;

package/dist/ra-core/src/core/useGetResourceLabel.js

@@ -0,0 +1,42 @@
+import { useResourceDefinitions } from './useResourceDefinitions';
+import { useTranslate } from '../i18n';
+import { humanize, inflect } from 'inflection';
+/**
+ * A hook which returns function to get a translated resource name. It will use the label option of the `Resource` component if it was provided.
+ *
+ * @returns {GetResourceLabel} A function which takes a resource name and an optional number indicating the number of items (used for pluralization) and returns a translated string.
+ * @example
+ * const Menu = () => {
+ *     const resources = useResourceDefinitions();
+ *     const getResourceLabel = useGetResourceLabel();
+ *
+ *     return (
+ *         <ul>
+ *             {Object.keys(resources).map(name => (
+ *                 <li key={name}>
+ *                     {getResourceLabel(name, 2)}
+ *                 </li>
+ *             ))}
+ *         </ul>
+ *     )
+ * }
+ */
+export const useGetResourceLabel = () => {
+    const translate = useTranslate();
+    const definitions = useResourceDefinitions();
+    return (resource, count = 2) => {
+        const resourceDefinition = definitions[resource];
+        const label = translate(`resources.${resource}.name`, {
+            smart_count: count,
+            _: resourceDefinition &&
+                resourceDefinition.options &&
+                resourceDefinition.options.label
+                ? translate(resourceDefinition.options.label, {
+                    smart_count: count,
+                    _: resourceDefinition.options.label,
+                })
+                : humanize(inflect(resource, count)),
+        });
+        return label;
+    };
+};

package/dist/ra-core/src/core/useIsOffline.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Hook to determine if the application is offline.
+ * It uses the onlineManager from react-query to check the online status.
+ * It returns true if the application is offline, false otherwise.
+ * @returns {boolean} - True if offline, false if online.
+ */
+export declare const useIsOffline: () => boolean;

package/dist/ra-core/src/core/useIsOffline.js

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { onlineManager } from '@tanstack/react-query';
+/**
+ * Hook to determine if the application is offline.
+ * It uses the onlineManager from react-query to check the online status.
+ * It returns true if the application is offline, false otherwise.
+ * @returns {boolean} - True if offline, false if online.
+ */
+export const useIsOffline = () => {
+    const [isOnline, setIsOnline] = React.useState(onlineManager.isOnline());
+    React.useEffect(() => {
+        const handleChange = () => {
+            setIsOnline(onlineManager.isOnline());
+        };
+        return onlineManager.subscribe(handleChange);
+    }, []);
+    return !isOnline;
+};

package/dist/ra-core/src/core/useResourceContext.d.ts

@@ -0,0 +1,36 @@
+import { ResourceContextValue } from './ResourceContext';
+/**
+ * Hook to read the resource from the ResourceContext.
+ *
+ * Must be used within a <ResourceContextProvider> (e.g. as a descendent of <Resource>
+ * or any reference related components), or called with a resource prop.
+ *
+ * @example
+ *
+ * const ResourceName = (props) => {
+ *   const resource = useResourceContext(props);
+ *   const getResourceLabel = useGetResourceLabel();
+ *   return <>{getResourceLabel(resource, 1)}</>;
+ * }
+ *
+ * // use it in a resource context
+ * const MyComponent = () => (
+ *   <ResourceContextProvider value="posts">
+ *     <ResourceName />
+ *     ...
+ *   </ResourceContextProvider>
+ * );
+ *
+ * // override resource via props
+ * const MyComponent = () => (
+ *   <>
+ *     <ResourceName resource="posts"/>
+ *     ...
+ *   </>
+ * );
+ *
+ * @returns {ResourceContextValue} The resource name, e.g. 'posts'
+ */
+export declare const useResourceContext: <ResourceInformationsType extends Partial<{
+    resource: string;
+}>>(props?: ResourceInformationsType) => ResourceContextValue;

package/dist/ra-core/src/core/useResourceContext.js

@@ -0,0 +1,38 @@
+import { useContext } from 'react';
+import { ResourceContext } from './ResourceContext';
+/**
+ * Hook to read the resource from the ResourceContext.
+ *
+ * Must be used within a <ResourceContextProvider> (e.g. as a descendent of <Resource>
+ * or any reference related components), or called with a resource prop.
+ *
+ * @example
+ *
+ * const ResourceName = (props) => {
+ *   const resource = useResourceContext(props);
+ *   const getResourceLabel = useGetResourceLabel();
+ *   return <>{getResourceLabel(resource, 1)}</>;
+ * }
+ *
+ * // use it in a resource context
+ * const MyComponent = () => (
+ *   <ResourceContextProvider value="posts">
+ *     <ResourceName />
+ *     ...
+ *   </ResourceContextProvider>
+ * );
+ *
+ * // override resource via props
+ * const MyComponent = () => (
+ *   <>
+ *     <ResourceName resource="posts"/>
+ *     ...
+ *   </>
+ * );
+ *
+ * @returns {ResourceContextValue} The resource name, e.g. 'posts'
+ */
+export const useResourceContext = (props) => {
+    const context = useContext(ResourceContext);
+    return (props && props.resource) || context;
+};

package/dist/ra-core/src/core/useResourceDefinition.d.ts

@@ -0,0 +1,31 @@
+import { RecordToStringFunction, ResourceDefinition, ResourceOptions } from '../types';
+/**
+ * Hook to get the definition of a given resource
+ *
+ * @example // Get the current resource definition (based on ResourceContext)
+ *
+ * const definition = useResourceDefinition();
+ * console.log(definition);
+ * // {
+ * //   name: 'posts',
+ * //   hasList: true,
+ * //   hasEdit: true,
+ * //   hasShow: true,
+ * //   hasCreate: true,
+ * //   options: {},
+ * //   icon: PostIcon,
+ * // }
+ *
+ * @example // Pass a resource prop to check a different resource definition
+ *
+ * const definition = useResourceDefinition({ resource: 'posts' });
+ */
+export declare const useResourceDefinition: <OptionsType extends ResourceOptions = any>(props?: UseResourceDefinitionOptions) => ResourceDefinition<OptionsType>;
+export interface UseResourceDefinitionOptions {
+    readonly resource?: string;
+    readonly hasList?: boolean;
+    readonly hasEdit?: boolean;
+    readonly hasShow?: boolean;
+    readonly hasCreate?: boolean;
+    readonly recordRepresentation?: React.ReactNode | RecordToStringFunction;
+}

package/dist/ra-core/src/core/useResourceDefinition.js

@@ -0,0 +1,48 @@
+import { useMemo } from 'react';
+import defaults from 'lodash/defaults.js';
+import { useResourceDefinitions } from './useResourceDefinitions';
+import { useResourceContext } from './useResourceContext';
+/**
+ * Hook to get the definition of a given resource
+ *
+ * @example // Get the current resource definition (based on ResourceContext)
+ *
+ * const definition = useResourceDefinition();
+ * console.log(definition);
+ * // {
+ * //   name: 'posts',
+ * //   hasList: true,
+ * //   hasEdit: true,
+ * //   hasShow: true,
+ * //   hasCreate: true,
+ * //   options: {},
+ * //   icon: PostIcon,
+ * // }
+ *
+ * @example // Pass a resource prop to check a different resource definition
+ *
+ * const definition = useResourceDefinition({ resource: 'posts' });
+ */
+export const useResourceDefinition = (props) => {
+    const resource = useResourceContext(props);
+    const resourceDefinitions = useResourceDefinitions();
+    const { hasCreate, hasEdit, hasList, hasShow, recordRepresentation } = props || {};
+    const definition = useMemo(() => {
+        return defaults({}, {
+            hasCreate,
+            hasEdit,
+            hasList,
+            hasShow,
+            recordRepresentation,
+        }, resource ? resourceDefinitions[resource] : {});
+    }, [
+        resource,
+        resourceDefinitions,
+        hasCreate,
+        hasEdit,
+        hasList,
+        hasShow,
+        recordRepresentation,
+    ]);
+    return definition;
+};

package/dist/ra-core/src/core/useResourceDefinitionContext.d.ts

@@ -0,0 +1 @@
+export declare const useResourceDefinitionContext: () => import("@strato-admin/core").ResourceDefinitionContextValue;

package/dist/ra-core/src/core/useResourceDefinitionContext.js

@@ -0,0 +1,3 @@
+import { useContext } from 'react';
+import { ResourceDefinitionContext } from './ResourceDefinitionContext';
+export const useResourceDefinitionContext = () => useContext(ResourceDefinitionContext);

package/dist/ra-core/src/core/useResourceDefinitions.d.ts

@@ -0,0 +1,21 @@
+import type { ResourceOptions } from '../types';
+import type { ResourceDefinitions } from './ResourceDefinitionContext';
+/**
+ * Get the definition of the all resources
+ *
+ * @example
+ *
+ * const definitions = useResourceDefinitions();
+ * console.log(definitions.posts);
+ * // {
+ * //   name: 'posts',
+ * //   hasList: true,
+ * //   hasEdit: true,
+ * //   hasShow: true,
+ * //   hasCreate: true,
+ * //   options: {},
+ * //   icon: PostIcon,
+ * //   recordRepresentation: 'title',
+ * // }
+ */
+export declare const useResourceDefinitions: <OptionsType extends ResourceOptions = any>() => ResourceDefinitions<OptionsType>;