@strato-admin/faker-ecommerce 0.1.1 → 0.3.0

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

@@ -0,0 +1,15 @@
+import { useSourceContext } from './SourceContext';
+/**
+ * Get the source prop for a field or input by checking if a source context is available.
+ * @param {string} source The original source prop
+ * @returns {string} The source prop, either the original one or the one modified by the SourceContext.
+ * @example
+ * const MyInput = ({ source, ...props }) => {
+ *   const finalSource = useWrappedSource(source);
+ *   return <input name={finalSource} {...props} />;
+ * };
+ */
+export const useWrappedSource = (source) => {
+    const sourceContext = useSourceContext();
+    return sourceContext.getSource(source);
+};

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

@@ -0,0 +1,3 @@
+import { DataProvider } from '../types';
+declare const DataProviderContext: import("react").Context<DataProvider | null>;
+export default DataProviderContext;

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

@@ -0,0 +1,4 @@
+import { createContext } from 'react';
+const DataProviderContext = createContext(null);
+DataProviderContext.displayName = 'DataProviderContext';
+export default DataProviderContext;

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

@@ -0,0 +1,6 @@
+declare class HttpError extends Error {
+    status: any;
+    body: any;
+    constructor(message: any, status: any, body?: any);
+}
+export default HttpError;

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

@@ -0,0 +1,19 @@
+class HttpError extends Error {
+    status;
+    body;
+    constructor(message, status, body = null) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        Object.setPrototypeOf(this, HttpError.prototype);
+        this.name = this.constructor.name;
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, this.constructor);
+        }
+        else {
+            this.stack = new Error(message).stack;
+        }
+        this.stack = new Error().stack;
+    }
+}
+export default HttpError;

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

@@ -0,0 +1,21 @@
+import { DataProvider } from '../types';
+export type DataProviderMatcher = (resource: string) => DataProvider;
+/**
+ * Combine multiple data providers into one.
+ *
+ * @param dataProviderMatcher A function that returns a data provider for a given resource.
+ *
+ * @example
+ * const dataProvider = combineDataProviders(resource => {
+ *    switch(resource) {
+ *       case 'posts':
+ *       case 'comments':
+ *          return dataProvider1;
+ *       case 'users':
+ *          return dataProvider2;
+ *       default:
+ *         throw new Error('Unknown resource');
+ *    }
+ * });
+ */
+export declare const combineDataProviders: (dataProviderMatcher: DataProviderMatcher) => DataProvider;

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

@@ -0,0 +1,32 @@
+import { defaultDataProvider } from './defaultDataProvider';
+/**
+ * Combine multiple data providers into one.
+ *
+ * @param dataProviderMatcher A function that returns a data provider for a given resource.
+ *
+ * @example
+ * const dataProvider = combineDataProviders(resource => {
+ *    switch(resource) {
+ *       case 'posts':
+ *       case 'comments':
+ *          return dataProvider1;
+ *       case 'users':
+ *          return dataProvider2;
+ *       default:
+ *         throw new Error('Unknown resource');
+ *    }
+ * });
+ */
+export const combineDataProviders = (dataProviderMatcher) => new Proxy(defaultDataProvider, {
+    get: (target, name) => {
+        if (name === 'then') {
+            return null;
+        }
+        return (resource, ...params) => {
+            if (typeof name === 'symbol') {
+                return;
+            }
+            return dataProviderMatcher(resource)[name](resource, ...params);
+        };
+    },
+});

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

@@ -0,0 +1,12 @@
+import { LegacyDataProvider, DataProvider } from '../types';
+/**
+ * Turn a function-based dataProvider to an object-based one
+ *
+ * Allows using legacy dataProviders transparently.
+ *
+ * @param {Function} legacyDataProvider A legacy dataProvider (type, resource, params) => Promise<any>
+ *
+ * @returns {Object} A dataProvider that react-admin can use
+ */
+declare const convertLegacyDataProvider: (legacyDataProvider: LegacyDataProvider) => DataProvider;
+export default convertLegacyDataProvider;

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

@@ -0,0 +1,40 @@
+import { CREATE, DELETE, DELETE_MANY, GET_LIST, GET_MANY, GET_MANY_REFERENCE, GET_ONE, UPDATE, UPDATE_MANY, } from './dataFetchActions';
+import { defaultDataProvider } from './defaultDataProvider';
+const fetchMap = {
+    create: CREATE,
+    delete: DELETE,
+    deleteMany: DELETE_MANY,
+    getList: GET_LIST,
+    getMany: GET_MANY,
+    getManyReference: GET_MANY_REFERENCE,
+    getOne: GET_ONE,
+    update: UPDATE,
+    updateMany: UPDATE_MANY,
+};
+/**
+ * Turn a function-based dataProvider to an object-based one
+ *
+ * Allows using legacy dataProviders transparently.
+ *
+ * @param {Function} legacyDataProvider A legacy dataProvider (type, resource, params) => Promise<any>
+ *
+ * @returns {Object} A dataProvider that react-admin can use
+ */
+const convertLegacyDataProvider = (legacyDataProvider) => {
+    const proxy = new Proxy(defaultDataProvider, {
+        get(_, name) {
+            return (resource, params) => {
+                if (Object.keys(fetchMap).includes(name.toString())) {
+                    const fetchType = fetchMap[name.toString()];
+                    return legacyDataProvider(fetchType, resource, params);
+                }
+                return legacyDataProvider(name.toString(), resource, params);
+            };
+        },
+        apply(_, __, args) {
+            return legacyDataProvider.apply(legacyDataProvider, args);
+        },
+    });
+    return proxy;
+};
+export default convertLegacyDataProvider;

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

@@ -0,0 +1,15 @@
+export declare const GET_LIST = "GET_LIST";
+export declare const GET_ONE = "GET_ONE";
+export declare const GET_MANY = "GET_MANY";
+export declare const GET_MANY_REFERENCE = "GET_MANY_REFERENCE";
+export declare const CREATE = "CREATE";
+export declare const UPDATE = "UPDATE";
+export declare const UPDATE_MANY = "UPDATE_MANY";
+export declare const DELETE = "DELETE";
+export declare const DELETE_MANY = "DELETE_MANY";
+export declare const fetchActionsWithRecordResponse: string[];
+export declare const fetchActionsWithArrayOfIdentifiedRecordsResponse: string[];
+export declare const fetchActionsWithArrayOfRecordsResponse: string[];
+export declare const fetchActionsWithTotalResponse: string[];
+export declare const reactAdminFetchActions: string[];
+export declare const sanitizeFetchType: (fetchType: string) => string;

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

@@ -0,0 +1,49 @@
+export const GET_LIST = 'GET_LIST';
+export const GET_ONE = 'GET_ONE';
+export const GET_MANY = 'GET_MANY';
+export const GET_MANY_REFERENCE = 'GET_MANY_REFERENCE';
+export const CREATE = 'CREATE';
+export const UPDATE = 'UPDATE';
+export const UPDATE_MANY = 'UPDATE_MANY';
+export const DELETE = 'DELETE';
+export const DELETE_MANY = 'DELETE_MANY';
+export const fetchActionsWithRecordResponse = ['getOne', 'create', 'update'];
+export const fetchActionsWithArrayOfIdentifiedRecordsResponse = [
+    'getList',
+    'getMany',
+    'getManyReference',
+];
+export const fetchActionsWithArrayOfRecordsResponse = [
+    ...fetchActionsWithArrayOfIdentifiedRecordsResponse,
+    'updateMany',
+    'deleteMany',
+];
+export const fetchActionsWithTotalResponse = ['getList', 'getManyReference'];
+export const reactAdminFetchActions = [
+    ...fetchActionsWithRecordResponse,
+    ...fetchActionsWithArrayOfRecordsResponse,
+];
+export const sanitizeFetchType = (fetchType) => {
+    switch (fetchType) {
+        case GET_LIST:
+            return 'getList';
+        case GET_ONE:
+            return 'getOne';
+        case GET_MANY:
+            return 'getMany';
+        case GET_MANY_REFERENCE:
+            return 'getManyReference';
+        case CREATE:
+            return 'create';
+        case UPDATE:
+            return 'update';
+        case UPDATE_MANY:
+            return 'updateMany';
+        case DELETE:
+            return 'delete';
+        case DELETE_MANY:
+            return 'deleteMany';
+        default:
+            return fetchType;
+    }
+};

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

@@ -0,0 +1,2 @@
+import { DataProvider } from '../types';
+export declare const defaultDataProvider: DataProvider;

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

@@ -0,0 +1,12 @@
+// avoids adding a context in tests
+export const defaultDataProvider = {
+    create: () => Promise.resolve({ data: null }),
+    delete: () => Promise.resolve({ data: null }),
+    deleteMany: () => Promise.resolve({ data: [] }),
+    getList: () => Promise.resolve({ data: [], total: 0 }),
+    getMany: () => Promise.resolve({ data: [] }),
+    getManyReference: () => Promise.resolve({ data: [], total: 0 }),
+    getOne: () => Promise.resolve({ data: null }),
+    update: () => Promise.resolve({ data: null }),
+    updateMany: () => Promise.resolve({ data: [] }),
+};

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

@@ -0,0 +1,32 @@
+import { stringify } from 'query-string';
+export interface Options extends RequestInit {
+    user?: {
+        authenticated?: boolean;
+        token?: string;
+    };
+}
+export declare const createHeadersFromOptions: (options: Options) => Headers;
+/**
+ * Utility function to make HTTP calls. It's similar to the HTML5 `fetch()`, except it handles JSON decoding and HTTP error codes automatically.
+ *
+ * @param url the URL to call
+ * @param options the options to pass to the HTTP call
+ * @param options.user the user object, used for the Authorization header
+ * @param options.user.token the token to pass as the Authorization header
+ * @param options.user.authenticated whether the user is authenticated or not (the Authorization header will be set only if this is true)
+ * @param options.headers the headers to pass to the HTTP call
+ *
+ * @returns {Promise} the Promise for a response object containing the following properties:
+ * - status: the HTTP status code
+ * - headers: the HTTP headers
+ * - body: the response body
+ * - json: the response body parsed as JSON
+ */
+export declare const fetchJson: (url: any, options?: Options) => Promise<{
+    status: number;
+    headers: Headers;
+    body: string;
+    json: any;
+}>;
+export declare const queryParameters: typeof stringify;
+export declare const flattenObject: (value: any, path?: string[]) => any;

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

@@ -0,0 +1,78 @@
+import HttpError from './HttpError';
+import { stringify } from 'query-string';
+export const createHeadersFromOptions = (options) => {
+    const requestHeaders = (options.headers ||
+        new Headers({
+            Accept: 'application/json',
+        }));
+    const hasBody = options && options.body;
+    const isContentTypeSet = requestHeaders.has('Content-Type');
+    const isGetMethod = !options?.method || options?.method === 'GET';
+    const isFormData = options?.body instanceof FormData;
+    const shouldSetContentType = hasBody && !isContentTypeSet && !isGetMethod && !isFormData;
+    if (shouldSetContentType) {
+        requestHeaders.set('Content-Type', 'application/json');
+    }
+    if (options.user && options.user.authenticated && options.user.token) {
+        requestHeaders.set('Authorization', options.user.token);
+    }
+    return requestHeaders;
+};
+/**
+ * Utility function to make HTTP calls. It's similar to the HTML5 `fetch()`, except it handles JSON decoding and HTTP error codes automatically.
+ *
+ * @param url the URL to call
+ * @param options the options to pass to the HTTP call
+ * @param options.user the user object, used for the Authorization header
+ * @param options.user.token the token to pass as the Authorization header
+ * @param options.user.authenticated whether the user is authenticated or not (the Authorization header will be set only if this is true)
+ * @param options.headers the headers to pass to the HTTP call
+ *
+ * @returns {Promise} the Promise for a response object containing the following properties:
+ * - status: the HTTP status code
+ * - headers: the HTTP headers
+ * - body: the response body
+ * - json: the response body parsed as JSON
+ */
+export const fetchJson = (url, options = {}) => {
+    const requestHeaders = createHeadersFromOptions(options);
+    return fetch(url, { ...options, headers: requestHeaders })
+        .then(response => response.text().then(text => ({
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        body: text,
+    })))
+        .then(({ status, statusText, headers, body }) => {
+        let json;
+        try {
+            json = JSON.parse(body);
+        }
+        catch (e) {
+            // not json, no big deal
+        }
+        if (status < 200 || status >= 300) {
+            return Promise.reject(new HttpError((json && json.message) || statusText, status, json));
+        }
+        return Promise.resolve({ status, headers, body, json });
+    });
+};
+export const queryParameters = stringify;
+const isValidObject = value => {
+    if (!value) {
+        return false;
+    }
+    const isArray = Array.isArray(value);
+    const isBuffer = typeof Buffer !== 'undefined' && Buffer.isBuffer(value);
+    const isObject = Object.prototype.toString.call(value) === '[object Object]';
+    const hasKeys = !!Object.keys(value).length;
+    return !isArray && !isBuffer && isObject && hasKeys;
+};
+export const flattenObject = (value, path = []) => {
+    if (isValidObject(value)) {
+        return Object.assign({}, ...Object.keys(value).map(key => flattenObject(value[key], path.concat([key]))));
+    }
+    else {
+        return path.length ? { [path.join('.')]: value } : value;
+    }
+};

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

@@ -0,0 +1,34 @@
+import convertLegacyDataProvider from './convertLegacyDataProvider';
+import DataProviderContext from './DataProviderContext';
+import HttpError from './HttpError';
+import * as fetchUtils from './fetch';
+import undoableEventEmitter from './undoableEventEmitter';
+export * from './combineDataProviders';
+export * from './dataFetchActions';
+export * from './defaultDataProvider';
+export * from './testDataProvider';
+export * from './withLifecycleCallbacks';
+export * from './useDataProvider';
+export * from './useIsDataLoaded';
+export * from './useLoading';
+export * from './useRefresh';
+export * from './useGetOne';
+export * from './useGetList';
+export * from './useGetMany';
+export * from './useGetManyAggregate';
+export * from './useGetManyReference';
+export * from './useGetRecordId';
+export * from './useCreate';
+export * from './useUpdate';
+export * from './useUpdateMany';
+export * from './useDelete';
+export * from './useDeleteMany';
+export * from './useInfiniteGetList';
+export * from './undo/';
+export * from './useMutationWithMutationMode';
+export type { Options } from './fetch';
+export { convertLegacyDataProvider, DataProviderContext, fetchUtils, HttpError, 
+/**
+ * @deprecated use the useTakeUndoableMutation hook instead
+ */
+undoableEventEmitter, };

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

@@ -0,0 +1,33 @@
+import convertLegacyDataProvider from './convertLegacyDataProvider';
+import DataProviderContext from './DataProviderContext';
+import HttpError from './HttpError';
+import * as fetchUtils from './fetch';
+import undoableEventEmitter from './undoableEventEmitter';
+export * from './combineDataProviders';
+export * from './dataFetchActions';
+export * from './defaultDataProvider';
+export * from './testDataProvider';
+export * from './withLifecycleCallbacks';
+export * from './useDataProvider';
+export * from './useIsDataLoaded';
+export * from './useLoading';
+export * from './useRefresh';
+export * from './useGetOne';
+export * from './useGetList';
+export * from './useGetMany';
+export * from './useGetManyAggregate';
+export * from './useGetManyReference';
+export * from './useGetRecordId';
+export * from './useCreate';
+export * from './useUpdate';
+export * from './useUpdateMany';
+export * from './useDelete';
+export * from './useDeleteMany';
+export * from './useInfiniteGetList';
+export * from './undo/';
+export * from './useMutationWithMutationMode';
+export { convertLegacyDataProvider, DataProviderContext, fetchUtils, HttpError, 
+/**
+ * @deprecated use the useTakeUndoableMutation hook instead
+ */
+undoableEventEmitter, };

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

@@ -0,0 +1,22 @@
+import type { QueryClient } from '@tanstack/react-query';
+export type PopulateQueryCacheOptions = {
+    data: Record<string, any[]>;
+    queryClient: QueryClient;
+    staleTime?: number;
+};
+/**
+ * Populate react-query's query cache with a data dictionary
+ *
+ * @example
+ * const data = {
+ *    posts: [{ id: 1, title: 'Hello, world' }, { id: 2, title: 'FooBar' }],
+ *    comments: [{ id: 1, post_id: 1, body: 'Nice post!' }],
+ * };
+ * populateQueryCache({ data, queryClient });
+ * // setQueryData(['posts', 'getOne', { id: '1' }], { id: 1, title: 'Hello, world' });
+ * // setQueryData(['posts', 'getOne', { id: '2' }], { id: 2, title: 'FooBar' });
+ * // setQueryData(['posts', 'getMany', { ids: ['1', '2'] }], [{ id: 1, title: 'Hello, world' }, { id: 2, title: 'FooBar' }]);
+ * // setQueryData(['comments', 'getOne', { id: '1' }], { id: 1, post_id: 1, body: 'Nice post!' });
+ * // setQueryData(['comments', 'getMany', { ids: ['1'] }], [{ id: 1, post_id: 1, body: 'Nice post!' });
+ */
+export declare const populateQueryCache: ({ data, queryClient, staleTime, }: PopulateQueryCacheOptions) => void;

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

@@ -0,0 +1,30 @@
+/**
+ * Populate react-query's query cache with a data dictionary
+ *
+ * @example
+ * const data = {
+ *    posts: [{ id: 1, title: 'Hello, world' }, { id: 2, title: 'FooBar' }],
+ *    comments: [{ id: 1, post_id: 1, body: 'Nice post!' }],
+ * };
+ * populateQueryCache({ data, queryClient });
+ * // setQueryData(['posts', 'getOne', { id: '1' }], { id: 1, title: 'Hello, world' });
+ * // setQueryData(['posts', 'getOne', { id: '2' }], { id: 2, title: 'FooBar' });
+ * // setQueryData(['posts', 'getMany', { ids: ['1', '2'] }], [{ id: 1, title: 'Hello, world' }, { id: 2, title: 'FooBar' }]);
+ * // setQueryData(['comments', 'getOne', { id: '1' }], { id: 1, post_id: 1, body: 'Nice post!' });
+ * // setQueryData(['comments', 'getMany', { ids: ['1'] }], [{ id: 1, post_id: 1, body: 'Nice post!' });
+ */
+export const populateQueryCache = ({ data, queryClient, staleTime = 1000, // ms
+ }) => {
+    // setQueryData doesn't accept a stale time option
+    // So we set an updatedAt in the future to make sure the data isn't considered stale
+    const updatedAt = Date.now() + staleTime;
+    Object.keys(data).forEach(resource => {
+        data[resource].forEach(record => {
+            if (!record || record.id == null)
+                return;
+            queryClient.setQueryData([resource, 'getOne', { id: String(record.id) }], record, { updatedAt });
+        });
+        const recordIds = data[resource].map(record => String(record.id));
+        queryClient.setQueryData([resource, 'getMany', { ids: recordIds }], data[resource], { updatedAt });
+    });
+};

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

@@ -0,0 +1,2 @@
+import { DataProvider } from '../types';
+export declare const testDataProvider: (overrides?: Partial<DataProvider>) => DataProvider;

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

@@ -0,0 +1,41 @@
+/**
+ * A dataProvider meant to be used in tests only. You can override any of its methods by passing a partial dataProvider.
+ *
+ * @example
+ * const dataProvider = testDataProvider({
+ *    getOne: async () => ({ data: { id: 123, title: 'foo' }})
+ * })
+ */
+const defaultTestDataProvider = {
+    create: async () => {
+        throw new Error('create is not implemented');
+    },
+    delete: async () => {
+        throw new Error('delete not implemented');
+    },
+    deleteMany: async () => {
+        throw new Error('deleteMany is not implemented');
+    },
+    getList: async () => {
+        throw new Error('getList is not implemented');
+    },
+    getMany: async () => {
+        throw new Error('getMany is not implemented');
+    },
+    getManyReference: async () => {
+        throw new Error('getManyReference is not implemented');
+    },
+    getOne: async () => {
+        throw new Error('getOne is not implemented');
+    },
+    update: async () => {
+        throw new Error('update not implemented');
+    },
+    updateMany: async () => {
+        throw new Error('updateMany not implemented');
+    },
+};
+export const testDataProvider = (overrides) => ({
+    ...defaultTestDataProvider,
+    ...overrides,
+});

package/dist/ra-core/src/dataProvider/undo/index.d.ts

@@ -0,0 +1,6 @@
+export * from './AddUndoableMutationContext';
+export * from './TakeUndoableMutationContext';
+export * from './UndoableMutationsContextProvider';
+export * from './types';
+export * from './useAddUndoableMutation';
+export * from './useTakeUndoableMutation';

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

@@ -0,0 +1,6 @@
+export * from './AddUndoableMutationContext';
+export * from './TakeUndoableMutationContext';
+export * from './UndoableMutationsContextProvider';
+export * from './types';
+export * from './useAddUndoableMutation';
+export * from './useTakeUndoableMutation';

package/dist/ra-core/src/dataProvider/undo/types.d.ts

@@ -0,0 +1,3 @@
+export type UndoableMutation = (params: {
+    isUndo: boolean;
+}) => void;

package/dist/ra-core/src/dataProvider/undo/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,3 @@
+import EventEmitter from 'eventemitter3';
+declare const _default: EventEmitter<string | symbol, any>;
+export default _default;

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

@@ -0,0 +1,2 @@
+import EventEmitter from 'eventemitter3';
+export default new EventEmitter();

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

@@ -0,0 +1,89 @@
+import { type UseMutationOptions, type UseMutationResult, type MutateOptions } from '@tanstack/react-query';
+import type { RaRecord, CreateParams, Identifier, DataProvider, MutationMode } from '../types';
+/**
+ * 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 declare const useCreate: <RecordType extends Omit<RaRecord, "id"> = any, MutationError = unknown, ResultRecordType extends RaRecord = RecordType & {
+    id: Identifier;
+}>(resource?: string, params?: Partial<CreateParams<Partial<RecordType>>>, options?: UseCreateOptions<RecordType, MutationError, ResultRecordType>) => UseCreateResult<RecordType, boolean, MutationError, ResultRecordType>;
+export interface UseCreateMutateParams<RecordType extends Omit<RaRecord, 'id'> = any> {
+    resource?: string;
+    data?: Partial<Omit<RecordType, 'id'>>;
+    meta?: any;
+}
+export type UseCreateOptions<RecordType extends Omit<RaRecord, 'id'> = any, MutationError = unknown, ResultRecordType extends RaRecord = RecordType & {
+    id: Identifier;
+}> = Omit<UseMutationOptions<ResultRecordType, MutationError, Partial<UseCreateMutateParams<RecordType>>>, 'mutationFn'> & {
+    mutationMode?: MutationMode;
+    returnPromise?: boolean;
+    getMutateWithMiddlewares?: <CreateFunctionType extends DataProvider['create'] = DataProvider['create']>(mutate: CreateFunctionType) => (...Params: Parameters<CreateFunctionType>) => ReturnType<CreateFunctionType>;
+};
+export type CreateMutationFunction<RecordType extends Omit<RaRecord, 'id'> = any, TReturnPromise extends boolean = boolean, MutationError = unknown, ResultRecordType extends RaRecord = RecordType & {
+    id: Identifier;
+}> = (resource?: string, params?: Partial<CreateParams<Partial<RecordType>>>, options?: MutateOptions<ResultRecordType, MutationError, Partial<UseCreateMutateParams<RecordType>>, unknown> & {
+    mutationMode?: MutationMode;
+    returnPromise?: TReturnPromise;
+}) => Promise<TReturnPromise extends true ? ResultRecordType : void>;
+export type UseCreateResult<RecordType extends Omit<RaRecord, 'id'> = any, TReturnPromise extends boolean = boolean, MutationError = unknown, ResultRecordType extends RaRecord = RecordType & {
+    id: Identifier;
+}> = [
+    CreateMutationFunction<RecordType, TReturnPromise, MutationError, ResultRecordType>,
+    UseMutationResult<ResultRecordType, MutationError, Partial<UseCreateMutateParams<RecordType>>, unknown> & {
+        isLoading: boolean;
+    }
+];