@strato-admin/faker-ecommerce 0.1.0 → 0.3.0

package/dist/ra-core/src/form/useRecordFromLocation.d.ts

@@ -0,0 +1,22 @@
+import { RaRecord } from '../types';
+import { RouterLocation } from '../routing';
+/**
+ * A hook that returns the record to use to override the values in a form
+ * @param options The hook options
+ * @param options.searchSource The key in the location search to use as a source for the record. Its content should be a stringified JSON object.
+ * @param options.stateSource The key in the location state to use as a source for the record
+ * @returns The record to use to override the values in a form
+ */
+export declare const useRecordFromLocation: (props?: UseRecordFromLocationOptions) => Partial<RaRecord<import("..").Identifier>> | null;
+export type UseRecordFromLocationOptions = {
+    searchSource?: string;
+    stateSource?: string;
+};
+/**
+ * Get the initial record from the location, whether it comes from the location
+ * state or is serialized in the url search part.
+ */
+export declare const getRecordFromLocation: ({ state, search }: RouterLocation, { searchSource, stateSource, }?: {
+    searchSource?: string;
+    stateSource?: string;
+}) => Partial<RaRecord> | null;

package/dist/ra-core/src/form/useRecordFromLocation.js

@@ -0,0 +1,59 @@
+import { useEffect, useRef, useState } from 'react';
+import { parse } from 'query-string';
+import isEqual from 'lodash/isEqual.js';
+import { useLocation } from '../routing';
+/**
+ * A hook that returns the record to use to override the values in a form
+ * @param options The hook options
+ * @param options.searchSource The key in the location search to use as a source for the record. Its content should be a stringified JSON object.
+ * @param options.stateSource The key in the location state to use as a source for the record
+ * @returns The record to use to override the values in a form
+ */
+export const useRecordFromLocation = (props = {}) => {
+    const { searchSource, stateSource } = props;
+    const location = useLocation();
+    const [recordFromLocation, setRecordFromLocation] = useState(() => getRecordFromLocation(location, {
+        stateSource,
+        searchSource,
+    }));
+    // To avoid having the form resets when the location changes but the final record is the same
+    // This is needed for forms such as TabbedForm or WizardForm that may change the location for their sections
+    const previousRecordRef = useRef(recordFromLocation);
+    useEffect(() => {
+        const newRecordFromLocation = getRecordFromLocation(location, {
+            stateSource,
+            searchSource,
+        });
+        if (!isEqual(newRecordFromLocation, previousRecordRef.current)) {
+            previousRecordRef.current = newRecordFromLocation;
+            setRecordFromLocation(newRecordFromLocation);
+        }
+    }, [location, stateSource, searchSource]);
+    return recordFromLocation;
+};
+/**
+ * Get the initial record from the location, whether it comes from the location
+ * state or is serialized in the url search part.
+ */
+export const getRecordFromLocation = ({ state, search }, { searchSource = 'source', stateSource = 'record', } = {}) => {
+    if (state && state[stateSource]) {
+        return state[stateSource];
+    }
+    if (search) {
+        try {
+            const searchParams = parse(search);
+            const source = searchParams[searchSource];
+            if (source) {
+                if (Array.isArray(source)) {
+                    console.error(`Failed to parse location ${searchSource} parameter '${search}'. To pre-fill some fields in the Create form, pass a stringified ${searchSource} parameter (e.g. '?${searchSource}={"title":"foo"}')`);
+                    return null;
+                }
+                return JSON.parse(source);
+            }
+        }
+        catch (e) {
+            console.error(`Failed to parse location ${searchSource} parameter '${search}'. To pre-fill some fields in the Create form, pass a stringified ${searchSource} parameter (e.g. '?${searchSource}={"title":"foo"}')`);
+        }
+    }
+    return null;
+};

package/dist/ra-core/src/form/useSuggestions.d.ts

@@ -0,0 +1,43 @@
+import { ReactElement } from 'react';
+import { UseChoicesOptions } from './choices/useChoices';
+export declare const useSuggestions: ({ allowCreate, choices, createText, createValue, createHintValue, limitChoicesToValue, matchSuggestion, optionText, optionValue, selectedItem, suggestionLimit, translateChoice, }: UseSuggestionsOptions) => {
+    getChoiceText: any;
+    getChoiceValue: any;
+    getSuggestions: (filter: any) => any[];
+};
+export interface UseSuggestionsOptions extends UseChoicesOptions {
+    allowCreate?: boolean;
+    allowDuplicates?: boolean;
+    choices?: any[];
+    createText?: string;
+    limitChoicesToValue?: boolean;
+    matchSuggestion?: (filter: string, suggestion: any, exact?: boolean) => boolean;
+    suggestionLimit?: number;
+    selectedItem?: any | any[];
+}
+/**
+ * Get the suggestions to display after applying a fuzzy search on the available choices
+ *
+ * @example
+ *
+ * getSuggestions({
+ *   choices: [{ id: 1, name: 'admin' }, { id: 2, name: 'publisher' }],
+ *   optionText: 'name',
+ *   optionValue: 'id',
+ *   getSuggestionText: choice => choice[optionText],
+ * })('pub')
+ *
+ * // Will return [{ id: 2, name: 'publisher' }]
+ * getSuggestions({
+ *   choices: [{ id: 1, name: 'admin' }, { id: 2, name: 'publisher' }],
+ *   optionText: 'name',
+ *   optionValue: 'id',
+ *   getSuggestionText: choice => choice[optionText],
+ * })('pub')
+ *
+ * // Will return [{ id: 2, name: 'publisher' }]
+ */
+export declare const getSuggestionsFactory: ({ allowCreate, choices, createText, createValue, optionText, optionValue, getChoiceText, getChoiceValue, limitChoicesToValue, matchSuggestion, selectedItem, suggestionLimit, }: UseSuggestionsOptions & {
+    getChoiceText: (choice: any) => string | ReactElement;
+    getChoiceValue: (choice: any) => string;
+}) => (filter: any) => any[];

package/dist/ra-core/src/form/useSuggestions.js

@@ -0,0 +1,186 @@
+import { useCallback, isValidElement } from 'react';
+import set from 'lodash/set.js';
+import { useChoices, } from './choices/useChoices';
+import { useTranslate } from '../i18n';
+/*
+ * Returns helper functions for suggestions handling.
+ *
+ * @param allowDuplicates A boolean indicating whether a suggestion can be added several times
+ * @param choices An array of available choices
+ * @param limitChoicesToValue A boolean indicating whether the initial suggestions should be limited to the currently selected one(s)
+ * @param matchSuggestion Optional unless `optionText` is a React element. Function which check whether a choice matches a filter. Must return a boolean.
+ * @param optionText Either a string defining the property to use to get the choice text, a function or a React element
+ * @param optionValue The property to use to get the choice value
+ * @param selectedItem The currently selected item. Maybe an array of selected items
+ * @param suggestionLimit The maximum number of suggestions returned
+ * @param translateChoice A boolean indicating whether to option text should be translated
+ *
+ * @returns An object with helper functions:
+ * - getChoiceText: Returns the choice text or a React element
+ * - getChoiceValue: Returns the choice value
+ * - getSuggestions: A function taking a filter value (string) and returning the matching suggestions
+ */
+export const useSuggestions = ({ allowCreate, choices, createText = "strato.action.create', createValue = '@@create', createHintValue = '@@ra-create-hint', limitChoicesToValue, matchSuggestion, optionText, optionValue, selectedItem, suggestionLimit = 0, translateChoice, }) => {
+    const translate = useTranslate();
+    const { getChoiceText, getChoiceValue } = useChoices({
+        optionText,
+        optionValue,
+        translateChoice,
+        createValue,
+        createHintValue,
+    });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    const getSuggestions = useCallback(getSuggestionsFactory({
+        allowCreate,
+        choices,
+        createText,
+        createValue,
+        getChoiceText,
+        getChoiceValue,
+        limitChoicesToValue,
+        matchSuggestion,
+        optionText,
+        optionValue,
+        selectedItem,
+        suggestionLimit,
+    }), [
+        allowCreate,
+        choices,
+        createText,
+        createValue,
+        getChoiceText,
+        getChoiceValue,
+        limitChoicesToValue,
+        matchSuggestion,
+        optionText,
+        optionValue,
+        selectedItem,
+        suggestionLimit,
+        translate,
+    ]);
+    return {
+        getChoiceText,
+        getChoiceValue,
+        getSuggestions,
+    };
+};
+const escapeRegExp = value => value ? value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') : ''; // $& means the whole matched string
+/**
+ * Default matcher implementation which check whether the suggestion text matches the filter.
+ */
+const defaultMatchSuggestion = getChoiceText => (filter, suggestion, exact = false) => {
+    const suggestionText = getChoiceText(suggestion);
+    const isReactElement = isValidElement(suggestionText);
+    const regex = escapeRegExp(filter);
+    return isReactElement
+        ? false
+        : suggestionText &&
+            !!suggestionText.match(
+            // We must escape any RegExp reserved characters to avoid errors
+            // For example, the filter might contain * which must be escaped as \*
+            new RegExp(exact ? `^${regex}$` : regex, 'i'));
+};
+/**
+ * Get the suggestions to display after applying a fuzzy search on the available choices
+ *
+ * @example
+ *
+ * getSuggestions({
+ *   choices: [{ id: 1, name: 'admin' }, { id: 2, name: 'publisher' }],
+ *   optionText: 'name',
+ *   optionValue: 'id',
+ *   getSuggestionText: choice => choice[optionText],
+ * })('pub')
+ *
+ * // Will return [{ id: 2, name: 'publisher' }]
+ * getSuggestions({
+ *   choices: [{ id: 1, name: 'admin' }, { id: 2, name: 'publisher' }],
+ *   optionText: 'name',
+ *   optionValue: 'id',
+ *   getSuggestionText: choice => choice[optionText],
+ * })('pub')
+ *
+ * // Will return [{ id: 2, name: 'publisher' }]
+ */
+export const getSuggestionsFactory = ({ allowCreate = false, choices = [], createText = "strato.action.create', createValue = '@@create', optionText = 'name', optionValue = 'id', getChoiceText, getChoiceValue, limitChoicesToValue = false, matchSuggestion = defaultMatchSuggestion(getChoiceText), selectedItem, suggestionLimit = 0, }) => filter => {
+    let suggestions = [];
+    // if an item is selected and matches the filter
+    if (selectedItem &&
+        !Array.isArray(selectedItem) &&
+        matchSuggestion(filter, selectedItem)) {
+        if (limitChoicesToValue) {
+            // display only the selected item
+            suggestions = choices.filter(choice => getChoiceValue(choice) === getChoiceValue(selectedItem));
+        }
+        else {
+            suggestions = [...choices];
+        }
+    }
+    else {
+        suggestions = choices.filter(choice => matchSuggestion(filter, choice) ||
+            (selectedItem != null &&
+                (!Array.isArray(selectedItem)
+                    ? getChoiceValue(choice) ===
+                        getChoiceValue(selectedItem)
+                    : selectedItem.some(selected => getChoiceValue(choice) ===
+                        getChoiceValue(selected)))));
+    }
+    suggestions = limitSuggestions(suggestions, suggestionLimit);
+    const hasExactMatch = suggestions.some(suggestion => matchSuggestion(filter, suggestion, true));
+    if (allowCreate) {
+        const filterIsSelectedItem = 
+        // If the selectedItem is an array (for example AutocompleteArrayInput)
+        // we shouldn't try to match
+        !!selectedItem && !Array.isArray(selectedItem)
+            ? matchSuggestion(filter, selectedItem, true)
+            : false;
+        if (!hasExactMatch && !filterIsSelectedItem) {
+            suggestions.push(getSuggestion({
+                optionText,
+                optionValue,
+                text: createText,
+                value: createValue,
+            }));
+        }
+    }
+    // Only keep unique items. Necessary because we might have fetched
+    // the currently selected choice in addition of the possible choices
+    // that may also contain it
+    const result = suggestions.filter((suggestion, index) => suggestions.indexOf(suggestion) === index);
+    return result;
+};
+/**
+ * @example
+ *
+ * limitSuggestions(
+ *  [{ id: 1, name: 'foo'}, { id: 2, name: 'bar' }],
+ *  1
+ * );
+ *
+ * // Will return [{ id: 1, name: 'foo' }]
+ *
+ * @param suggestions List of suggestions
+ * @param limit
+ */
+const limitSuggestions = (suggestions, limit = 0) => Number.isInteger(limit) && limit > 0
+    ? suggestions.slice(0, limit)
+    : suggestions;
+/**
+ * addSuggestion(
+ *  [{ id: 1, name: 'foo'}, { id: 2, name: 'bar' }],
+ * );
+ *
+ * // Will return [{ id: null, name: '' }, { id: 1, name: 'foo' }, { id: 2, name: 'bar' }]
+ *
+ * @param suggestions List of suggestions
+ * @param options
+ * @param options.optionText
+ */
+const getSuggestion = ({ optionText = 'name', optionValue = 'id', text = '', value = null, }) => {
+    const suggestion = {};
+    set(suggestion, optionValue, value);
+    if (typeof optionText === 'string') {
+        set(suggestion, optionText, text);
+    }
+    return suggestion;
+};

package/dist/ra-core/src/form/validation/getSimpleValidationResolver.d.ts

@@ -0,0 +1,31 @@
+import { FieldValues } from 'react-hook-form';
+/**
+ * Convert a simple validation function that returns an object matching the form shape with errors
+ * to a validation resolver compatible with react-hook-form.
+ *
+ * @example
+ * const validate = (values: any) => {
+ *     if (values.username == null || values.username.trim() === '') {
+ *         return { username: 'Required' };
+ *     }
+ * }
+ *
+ * const validationResolver = getSimpleValidationResolver(validate);
+ *
+ * const UserForm = () => (
+ *     <Form
+ *         defaultValues={{ username: 'John' }}
+ *         validationResolver={validationResolver}
+ *     >
+ *         <TextField source="username" />
+ *     </Form>
+ * );
+ */
+export declare const getSimpleValidationResolver: (validate: ValidateForm) => (data: FieldValues) => Promise<{
+    values: FieldValues;
+    errors: {};
+} | {
+    values: {};
+    errors: any;
+}>;
+export type ValidateForm = (data: FieldValues) => FieldValues | Promise<FieldValues>;

package/dist/ra-core/src/form/validation/getSimpleValidationResolver.js

@@ -0,0 +1,87 @@
+/**
+ * Convert a simple validation function that returns an object matching the form shape with errors
+ * to a validation resolver compatible with react-hook-form.
+ *
+ * @example
+ * const validate = (values: any) => {
+ *     if (values.username == null || values.username.trim() === '') {
+ *         return { username: 'Required' };
+ *     }
+ * }
+ *
+ * const validationResolver = getSimpleValidationResolver(validate);
+ *
+ * const UserForm = () => (
+ *     <Form
+ *         defaultValues={{ username: 'John' }}
+ *         validationResolver={validationResolver}
+ *     >
+ *         <TextField source="username" />
+ *     </Form>
+ * );
+ */
+export const getSimpleValidationResolver = (validate) => async (data) => {
+    const errors = await validate(data);
+    // If there are no errors, early return the form values
+    if (!errors || isEmptyObject(errors)) {
+        return { values: data, errors: {} };
+    }
+    // Else, we return an error object shaped like errors but having for each leaf
+    // `type: 'manual'` and a `message` prop like react-hook-form expects it
+    const transformedErrors = transformErrorFields(errors);
+    // Sometimes we still need to transform the error object to realize there are actually
+    // no errors in it.
+    //   e.g. with an ArrayInput we can get something like: `{backlinks: [{}, {}]}`
+    // If, after transformation, there are no errors, we return the form values
+    if (!transformedErrors || isEmptyObject(transformedErrors)) {
+        return { values: data, errors: {} };
+    }
+    // Else return the errors and no values
+    return {
+        values: {},
+        errors: transformedErrors,
+    };
+};
+const transformErrorFields = (error) => {
+    return Object.keys(error).reduce((acc, field) => {
+        // Handle arrays
+        if (Array.isArray(error[field])) {
+            let arrayHasErrors = false;
+            const transformedArrayErrors = error[field].map(item => {
+                if (!isEmptyObject(item)) {
+                    arrayHasErrors = true;
+                }
+                return transformErrorFields(item);
+            });
+            if (!arrayHasErrors) {
+                return acc;
+            }
+            return {
+                ...acc,
+                [field]: transformedArrayErrors,
+            };
+        }
+        // Handle objects
+        if (isEmptyObject(error[field])) {
+            return acc;
+        }
+        if (typeof error[field] === 'object' &&
+            !isRaTranslationObj(error[field])) {
+            return {
+                ...acc,
+                [field]: transformErrorFields(error[field]),
+            };
+        }
+        // Handle leaf (either primary type or RaTranslationObj)
+        return {
+            ...acc,
+            [field]: addTypeAndMessage(error[field]),
+        };
+    }, {});
+};
+const addTypeAndMessage = (error) => ({
+    type: 'manual',
+    message: isRaTranslationObj(error) ? error : { message: error },
+});
+const isRaTranslationObj = (obj) => Object.keys(obj).includes('message') && Object.keys(obj).includes('args');
+const isEmptyObject = (obj) => obj == null || Object.getOwnPropertyNames(obj).length === 0;

package/dist/ra-core/src/form/validation/index.d.ts

@@ -0,0 +1,7 @@
+export * from './getSimpleValidationResolver';
+export * from './setSubmissionErrors';
+export * from './useGetValidationErrorMessage';
+export * from './useNotifyIsFormInvalid';
+export * from './useUnique';
+export * from './validate';
+export * from './ValidationError';

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

@@ -0,0 +1,7 @@
+export * from './getSimpleValidationResolver';
+export * from './setSubmissionErrors';
+export * from './useGetValidationErrorMessage';
+export * from './useNotifyIsFormInvalid';
+export * from './useUnique';
+export * from './validate';
+export * from './ValidationError';

package/dist/ra-core/src/form/validation/setSubmissionErrors.d.ts

@@ -0,0 +1,21 @@
+import { FieldValues, UseFormSetError } from 'react-hook-form';
+/**
+ * This internal function is used to convert an object matching the form shape with errors to a
+ * format compatible with react-hook-form. It's used to handle submission errors. Only useful when
+ * you are implementing a custom form without leveraging our Form component.
+ *
+ * @example
+ * const MyForm = () => {
+ *     const { register, handleSubmit, setError } = useForm();
+ *     const onSubmit = data => {
+ *         return saveAsync(data).catch(error => setSubmissionErrors(error.body.details));
+ *     };
+ *
+ *     return (
+ *         <form onSubmit={handleSubmit(onSubmit)}>
+ *             ...
+ *         </form>
+ *     );
+ * };
+ */
+export declare const setSubmissionErrors: (errors: FieldValues, setError: UseFormSetError<FieldValues>) => void;

package/dist/ra-core/src/form/validation/setSubmissionErrors.js

@@ -0,0 +1,34 @@
+/**
+ * This internal function is used to convert an object matching the form shape with errors to a
+ * format compatible with react-hook-form. It's used to handle submission errors. Only useful when
+ * you are implementing a custom form without leveraging our Form component.
+ *
+ * @example
+ * const MyForm = () => {
+ *     const { register, handleSubmit, setError } = useForm();
+ *     const onSubmit = data => {
+ *         return saveAsync(data).catch(error => setSubmissionErrors(error.body.details));
+ *     };
+ *
+ *     return (
+ *         <form onSubmit={handleSubmit(onSubmit)}>
+ *             ...
+ *         </form>
+ *     );
+ * };
+ */
+export const setSubmissionErrors = (errors, setError) => {
+    const setErrorFromObject = (errors, rootPath) => {
+        Object.entries(errors).forEach(([name, error]) => {
+            if (typeof error === 'object') {
+                setErrorFromObject(error, `${rootPath}${name}.`);
+                return;
+            }
+            setError(`${rootPath}${name}`, {
+                type: 'server',
+                message: error.toString(),
+            });
+        });
+    };
+    setErrorFromObject(errors, '');
+};

package/dist/ra-core/src/form/validation/useGetValidationErrorMessage.d.ts

@@ -0,0 +1,26 @@
+import { ValidationErrorMessage } from './validate';
+/**
+ * @deprecated
+ * This internal hook returns a function that can translate an error message.
+ * It handles simple string errors and those which have a message and args.
+ * Only useful if you are implementing custom inputs without leveraging our useInput hook.
+ *
+ * @example
+ * const MyInput = props => {
+ *      const { field, fieldState } = useController(props);
+ *      useEffect(() => {
+ *          if (fieldState.error) {
+ *              const errorMessage = useGetValidationErrorMessage(fieldState.error);
+ *              alert(errorMessage);
+ *          }
+ *      }, [fieldState.error]);
+ *
+ *      return (
+ *          <input {...field} />
+ *      );
+ * }
+ *
+ * @see ValidationErrorMessage
+ * @see ValidationErrorMessageWithArgs
+ */
+export declare const useGetValidationErrorMessage: () => (error: ValidationErrorMessage) => string;

package/dist/ra-core/src/form/validation/useGetValidationErrorMessage.js

@@ -0,0 +1,35 @@
+import { useTranslate } from '../../i18n';
+/**
+ * @deprecated
+ * This internal hook returns a function that can translate an error message.
+ * It handles simple string errors and those which have a message and args.
+ * Only useful if you are implementing custom inputs without leveraging our useInput hook.
+ *
+ * @example
+ * const MyInput = props => {
+ *      const { field, fieldState } = useController(props);
+ *      useEffect(() => {
+ *          if (fieldState.error) {
+ *              const errorMessage = useGetValidationErrorMessage(fieldState.error);
+ *              alert(errorMessage);
+ *          }
+ *      }, [fieldState.error]);
+ *
+ *      return (
+ *          <input {...field} />
+ *      );
+ * }
+ *
+ * @see ValidationErrorMessage
+ * @see ValidationErrorMessageWithArgs
+ */
+export const useGetValidationErrorMessage = () => {
+    const translate = useTranslate();
+    return (error) => {
+        if (error.message != null) {
+            const { message, args } = error;
+            return translate(message, { _: message, ...args });
+        }
+        return translate(error, { _: error });
+    };
+};

package/dist/ra-core/src/form/validation/useNotifyIsFormInvalid.d.ts

@@ -0,0 +1,9 @@
+import { Control } from 'react-hook-form';
+/**
+ * This hook display an error message on submit in Form and SaveButton.
+ *
+ * We can't do the form validity check in the form submit handler
+ * as the form state may not have been updated yet when onSubmit validation mode is enabled
+ * or when the form hasn't been touched at all.
+ */
+export declare const useNotifyIsFormInvalid: (control?: Control, enabled?: boolean) => void;

package/dist/ra-core/src/form/validation/useNotifyIsFormInvalid.js

@@ -0,0 +1,30 @@
+import { useEffect, useRef } from 'react';
+import { useFormState } from 'react-hook-form';
+import { useNotify } from '../../notification';
+/**
+ * This hook display an error message on submit in Form and SaveButton.
+ *
+ * We can't do the form validity check in the form submit handler
+ * as the form state may not have been updated yet when onSubmit validation mode is enabled
+ * or when the form hasn't been touched at all.
+ */
+export const useNotifyIsFormInvalid = (control, enabled = true) => {
+    const { submitCount, errors } = useFormState(control ? { control } : undefined);
+    const submitCountRef = useRef(submitCount);
+    const notify = useNotify();
+    useEffect(() => {
+        // Checking the submit count allows us to only display the notification after users
+        // tried to submit
+        if (submitCount > submitCountRef.current && enabled) {
+            submitCountRef.current = submitCount;
+            if (Object.keys(errors).length > 0) {
+                const serverError = typeof errors.root?.serverError?.message === 'string'
+                    ? errors.root.serverError.message
+                    : undefined;
+                notify(serverError || "strato.message.invalid_form', {
+                    type: 'error',
+                });
+            }
+        }
+    }, [errors, submitCount, notify, enabled]);
+};

package/dist/ra-core/src/form/validation/useUnique.d.ts

@@ -0,0 +1,57 @@
+import { InputProps } from '../useInput';
+/**
+ * A hook that returns a validation function checking for a record field uniqueness
+ * by calling the dataProvider getList function with a filter.
+ *
+ * @example // Passing options at declaration time
+ * const UserCreateForm = () => {
+ *     const unique = useUnique({ message: 'Username is already used'});
+ *     return (
+ *         <SimpleForm>
+ *             <TextInput source="username" validate={unique()} />
+ *         </SimpleForm>
+ *     );
+ * }
+ *
+ * @example // Passing options at call time
+ * const UserCreateForm = () => {
+ *     const unique = useUnique();
+ *     return (
+ *         <SimpleForm>
+ *             <TextInput source="username" validate={unique({ message: 'Username is already used'})} />
+ *         </SimpleForm>
+ *     );
+ * }
+ *
+ * @example // With additional filters
+ * const UserCreateForm = () => {
+ *     const unique = useUnique();
+ *     return (
+ *         <SimpleForm>
+ *             <ReferenceInput source="organization_id" reference="organizations" />
+ *             <FormDataConsumer>
+ *                 {({ formData }) => (
+ *                     <TextInput
+ *                         source="username"
+ *                         validate={unique({ filter: { organization_id: formData.organization_id })}
+ *                     />
+ *                 )}
+ *             </FormDataConsumer>
+ *         </SimpleForm>
+ *     );
+ * }
+ */
+export declare const useUnique: (options?: UseUniqueOptions) => (callTimeOptions?: UseUniqueOptions) => (value: any, allValues: any, props: InputProps) => Promise<string | {
+    message: any;
+    args: {
+        source: string;
+        value: any;
+        field: string | number | bigint | true | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | null;
+    };
+} | undefined>;
+export type UseUniqueOptions = {
+    debounce?: number;
+    resource?: string;
+    message?: string;
+    filter?: Record<string, any>;
+};