@rjsf/utils 5.0.0-beta.2 → 5.0.0-beta.4

package/dist/index.d.ts

@@ -1,38 +1,1221 @@
-import allowAdditionalItems from "./allowAdditionalItems";
-import asNumber from "./asNumber";
-import canExpand from "./canExpand";
-import createSchemaUtils from "./createSchemaUtils";
-import dataURItoBlob from "./dataURItoBlob";
-import deepEquals from "./deepEquals";
-import findSchemaDefinition from "./findSchemaDefinition";
-import getInputProps from "./getInputProps";
-import getSchemaType from "./getSchemaType";
-import getSubmitButtonOptions from "./getSubmitButtonOptions";
-import getTemplate from "./getTemplate";
-import getUiOptions from "./getUiOptions";
-import getWidget from "./getWidget";
-import guessType from "./guessType";
-import hasWidget from "./hasWidget";
-import isConstant from "./isConstant";
-import isCustomWidget from "./isCustomWidget";
-import isFixedItems from "./isFixedItems";
-import isObject from "./isObject";
-import localToUTC from "./localToUTC";
-import mergeDefaultsWithFormData from "./mergeDefaultsWithFormData";
-import mergeObjects from "./mergeObjects";
-import mergeSchemas from "./mergeSchemas";
-import optionsList from "./optionsList";
-import orderProperties from "./orderProperties";
-import pad from "./pad";
-import parseDateString from "./parseDateString";
-import processSelectValue from "./processSelectValue";
-import rangeSpec from "./rangeSpec";
-import schemaRequiresTrueValue from "./schemaRequiresTrueValue";
-import shouldRender from "./shouldRender";
-import toConstant from "./toConstant";
-import toDateString from "./toDateString";
-import utcToLocal from "./utcToLocal";
-export * from "./types";
-export * from "./constants";
-export * from "./schema";
-export { allowAdditionalItems, asNumber, canExpand, createSchemaUtils, dataURItoBlob, deepEquals, findSchemaDefinition, getInputProps, getSchemaType, getSubmitButtonOptions, getTemplate, getUiOptions, getWidget, guessType, hasWidget, isConstant, isCustomWidget, isFixedItems, isObject, localToUTC, mergeDefaultsWithFormData, mergeObjects, mergeSchemas, optionsList, orderProperties, pad, parseDateString, processSelectValue, rangeSpec, schemaRequiresTrueValue, shouldRender, toConstant, toDateString, utcToLocal, };
+import React from 'react';
+import * as json_schema from 'json-schema';
+import { JSONSchema7, JSONSchema7Definition } from 'json-schema';
+
+/** The representation of any generic object type, usually used as an intersection on other types to make them more
+ * flexible in the properties they support (i.e. anything else)
+ */
+declare type GenericObjectType = {
+    [name: string]: any;
+};
+/** Map the JSONSchema7 to our own type so that we can easily bump to JSONSchema8 at some future date and only have to
+ * update this one type.
+ */
+declare type RJSFSchema = JSONSchema7;
+/** Map the JSONSchema7Definition to our own type so that we can easily bump to JSONSchema8Definition at some future
+ * date and only have to update this one type.
+ */
+declare type RJSFSchemaDefinition = JSONSchema7Definition;
+/** The interface representing a Date object that contains an optional time */
+interface DateObject {
+    /** The year of the Date */
+    year: number;
+    /** The month of the Date */
+    month: number;
+    /** The day of the Date */
+    day: number;
+    /** The optional hours for the time of a Date */
+    hour?: number;
+    /** The optional minutes for the time of a Date */
+    minute?: number;
+    /** The optional seconds for the time of a Date */
+    second?: number;
+}
+/** Properties describing a Range specification in terms of attribute that can be added to the `HTML` `<input>` */
+declare type RangeSpecType = {
+    /** Specifies the interval between legal numbers in an input field */
+    step?: number;
+    /** Specifies a minimum value for an <input> element */
+    min?: number;
+    /** Specifies the maximum value for an <input> element */
+    max?: number;
+};
+/** Properties describing a Range specification in terms of attribute that can be added to the `HTML` `<input>` */
+declare type InputPropsType = Omit<RangeSpecType, "step"> & {
+    /** Specifies the type of the <input> element */
+    type: string;
+    /** Specifies the interval between legal numbers in an input field or "any" */
+    step?: number | "any";
+    /** Specifies the `autoComplete` value for an <input> element */
+    autoComplete?: HTMLInputElement["autocomplete"];
+};
+/** Type describing an id used for a field in the `IdSchema` */
+declare type FieldId = {
+    /** The id for a field */
+    $id: string;
+};
+/** Type describing a recursive structure of `FieldId`s for an object with a non-empty set of keys */
+declare type IdSchema<T = any> = FieldId & {
+    [key in keyof T]?: IdSchema<T[key]>;
+};
+/** Type describing a name used for a field in the `PathSchema` */
+declare type FieldPath = {
+    /** The name of a field */
+    $name: string;
+};
+/** Type describing a recursive structure of `FieldPath`s for an object with a non-empty set of keys */
+declare type PathSchema<T = any> = FieldPath & {
+    [key in keyof T]?: PathSchema<T[key]>;
+};
+/** The type for error produced by RJSF schema validation */
+declare type RJSFValidationError = {
+    /** Name of the error, for example, "required" or "minLength" */
+    name?: string;
+    /** Message, for example, "is a required property" or "should NOT be shorter than 3 characters" */
+    message?: string;
+    /** An object with the error params returned by ajv
+     * ([see doc](https://github.com/ajv-validator/ajv/tree/6a671057ea6aae690b5967ee26a0ddf8452c6297#error-parameters)
+     * for more info)
+     */
+    params?: any;
+    /** A string in Javascript property accessor notation to the data path of the field with the error. For example,
+     * `.name` or `['first-name']`
+     */
+    property?: string;
+    /** JSON pointer to the schema of the keyword that failed validation. For example, `#/fields/firstName/required`.
+     * (Note: this may sometimes be wrong due to a [bug in ajv](https://github.com/ajv-validator/ajv/issues/512))
+     */
+    schemaPath?: string;
+    /** Full error name, for example ".name is a required property" */
+    stack: string;
+};
+/** The type that describes an error in a field */
+declare type FieldError = string;
+/** The type that describes the list of errors for a field */
+declare type FieldErrors = {
+    /** The list of errors for the field */
+    __errors?: FieldError[];
+};
+/** Type describing a recursive structure of `FieldErrors`s for an object with a non-empty set of keys */
+declare type ErrorSchema<T = any> = FieldErrors & {
+    [key in keyof T]?: ErrorSchema<T[key]>;
+};
+/** Type that describes the list of errors for a field being actively validated by a custom validator */
+declare type FieldValidation = FieldErrors & {
+    /** Function that will add a new `message` to the list of errors */
+    addError: (message: string) => void;
+};
+/** Type describing a recursive structure of `FieldValidation`s for an object with a non-empty set of keys */
+declare type FormValidation<T = any> = FieldValidation & {
+    [key in keyof T]?: FormValidation<T[key]>;
+};
+/** The properties that are passed to an `ErrorList` implementation */
+declare type ErrorListProps<T = any, F = any> = {
+    /** The errorSchema constructed by `Form` */
+    errorSchema: ErrorSchema<T>;
+    /** An array of the errors */
+    errors: RJSFValidationError[];
+    /** The `formContext` object that was passed to `Form` */
+    formContext?: F;
+    /** The schema that was passed to `Form` */
+    schema: RJSFSchema;
+    /** The uiSchema that was passed to `Form` */
+    uiSchema?: UiSchema<T, F>;
+};
+/** The set of `Fields` stored in the `Registry` */
+declare type RegistryFieldsType<T = any, F = any> = {
+    /** A `Field` indexed by `name` */
+    [name: string]: Field<T, F>;
+};
+/** The set of `Widgets` stored in the `Registry` */
+declare type RegistryWidgetsType<T = any, F = any> = {
+    /** A `Widget` indexed by `name` */
+    [name: string]: Widget<T, F>;
+};
+/** The set of RJSF templates that can be overridden by themes or users */
+interface TemplatesType<T = any, F = any> {
+    /** The template to use while rendering normal or fixed array fields */
+    ArrayFieldTemplate: React.ComponentType<ArrayFieldTemplateProps<T, F>>;
+    /** The template to use while rendering the description for an array field */
+    ArrayFieldDescriptionTemplate: React.ComponentType<ArrayFieldDescriptionProps<T, F>>;
+    /** The template to use while rendering an item in an array field */
+    ArrayFieldItemTemplate: React.ComponentType<ArrayFieldTemplateItemType<T, F>>;
+    /** The template to use while rendering the title for an array field */
+    ArrayFieldTitleTemplate: React.ComponentType<ArrayFieldTitleProps<T, F>>;
+    /** The template to use while rendering the standard html input */
+    BaseInputTemplate: React.ComponentType<WidgetProps<T, F>>;
+    /** The template to use for rendering the description of a field */
+    DescriptionFieldTemplate: React.ComponentType<DescriptionFieldProps<T, F>>;
+    /** The template to use while rendering form errors */
+    ErrorListTemplate: React.ComponentType<ErrorListProps<T, F>>;
+    /** The template to use while rendering a field */
+    FieldTemplate: React.ComponentType<FieldTemplateProps<T, F>>;
+    /** The template to use while rendering an object */
+    ObjectFieldTemplate: React.ComponentType<ObjectFieldTemplateProps<T, F>>;
+    /** The template to use for rendering the title of a field */
+    TitleFieldTemplate: React.ComponentType<TitleFieldProps<T, F>>;
+    /** The template to use for rendering information about an unsupported field type in the schema */
+    UnsupportedFieldTemplate: React.ComponentType<UnsupportedFieldProps<T, F>>;
+    /** The set of templates associated with buttons in the form */
+    ButtonTemplates: {
+        /** The template to use for the main `Submit` button  */
+        SubmitButton: React.ComponentType<SubmitButtonProps<T, F>>;
+        /** The template to use for the Add button used for AdditionalProperties and Array items */
+        AddButton: React.ComponentType<IconButtonProps>;
+        /** The template to use for the Move Down button used for Array items */
+        MoveDownButton: React.ComponentType<IconButtonProps>;
+        /** The template to use for the Move Up button used for Array items */
+        MoveUpButton: React.ComponentType<IconButtonProps>;
+        /** The template to use for the Remove button used for AdditionalProperties and Array items */
+        RemoveButton: React.ComponentType<IconButtonProps>;
+    };
+}
+/** The object containing the registered core, theme and custom fields and widgets as well as the root schema, form
+ * context, schema utils and templates.
+ */
+interface Registry<T = any, F = any> {
+    /** The set of all fields used by the `Form`. Includes fields from `core`, theme-specific fields and any custom
+     * registered fields
+     */
+    fields: RegistryFieldsType<T, F>;
+    /** The set of templates used by the `Form`. Includes templates from `core`, theme-specific fields and any custom
+     * registered templates
+     */
+    templates: TemplatesType<T, F>;
+    /** The set of all widgets used by the `Form`. Includes widgets from `core`, theme-specific widgets and any custom
+     * registered widgets
+     */
+    widgets: RegistryWidgetsType<T, F>;
+    /** The `formContext` object that was passed to `Form` */
+    formContext: F;
+    /** The root schema, as passed to the `Form`, which can contain referenced definitions */
+    rootSchema: RJSFSchema;
+    /** The current implementation of the `SchemaUtilsType` (from `@rjsf/utils`) in use by the `Form`.  Used to call any
+     * of the validation-schema-based utility functions
+     */
+    schemaUtils: SchemaUtilsType<T>;
+}
+/** The properties that are passed to a Field implementation */
+interface FieldProps<T = any, F = any> extends GenericObjectType, Pick<React.HTMLAttributes<HTMLElement>, Exclude<keyof React.HTMLAttributes<HTMLElement>, "onBlur" | "onFocus" | "onChange">> {
+    /** The JSON subschema object for this field */
+    schema: RJSFSchema;
+    /** The uiSchema for this field */
+    uiSchema?: UiSchema<T, F>;
+    /** The tree of unique ids for every child field */
+    idSchema: IdSchema<T>;
+    /** The data for this field */
+    formData: T;
+    /** The tree of errors for this field and its children */
+    errorSchema?: ErrorSchema<T>;
+    /** The field change event handler; called with the updated form data and an optional `ErrorSchema` */
+    onChange: (newFormData: T, es?: ErrorSchema<T>) => any;
+    /** The input blur event handler; call it with the field id and value */
+    onBlur: (id: string, value: any) => void;
+    /** The input focus event handler; call it with the field id and value */
+    onFocus: (id: string, value: any) => void;
+    /** The `formContext` object that you passed to `Form` */
+    formContext?: F;
+    /** A boolean value stating if the field should autofocus */
+    autofocus?: boolean;
+    /** A boolean value stating if the field is disabled */
+    disabled: boolean;
+    /** A boolean value stating if the field is hiding its errors */
+    hideError?: boolean;
+    /** A boolean value stating if the field is read-only */
+    readonly: boolean;
+    /** The required status of this field */
+    required?: boolean;
+    /** The unique name of the field, usually derived from the name of the property in the JSONSchema */
+    name: string;
+    /** The `registry` object */
+    registry: Registry<T, F>;
+}
+/** The definition of a React-based Field component */
+declare type Field<T = any, F = any> = React.ComponentType<FieldProps<T, F>>;
+/** The properties that are passed to a FieldTemplate implementation */
+declare type FieldTemplateProps<T = any, F = any> = {
+    /** The id of the field in the hierarchy. You can use it to render a label targeting the wrapped widget */
+    id: string;
+    /** A string containing the base CSS classes, merged with any custom ones defined in your uiSchema */
+    classNames?: string;
+    /** The computed label for this field, as a string */
+    label: string;
+    /** A component instance rendering the field description, if one is defined (this will use any custom
+     * `DescriptionField` defined)
+     */
+    description?: React.ReactElement;
+    /** A string containing any `ui:description` uiSchema directive defined */
+    rawDescription?: string;
+    /** The field or widget component instance for this field row */
+    children: React.ReactElement;
+    /** A component instance listing any encountered errors for this field */
+    errors?: React.ReactElement;
+    /** An array of strings listing all generated error messages from encountered errors for this field */
+    rawErrors?: string[];
+    /** A component instance rendering any `ui:help` uiSchema directive defined */
+    help?: React.ReactElement;
+    /** A string containing any `ui:help` uiSchema directive defined. **NOTE:** `rawHelp` will be `undefined` if passed
+     * `ui:help` is a React component instead of a string
+     */
+    rawHelp?: string;
+    /** A boolean value stating if the field should be hidden */
+    hidden?: boolean;
+    /** A boolean value stating if the field is required */
+    required?: boolean;
+    /** A boolean value stating if the field is read-only */
+    readonly: boolean;
+    /** A boolean value stating if the field is hiding its errors */
+    hideError?: boolean;
+    /** A boolean value stating if the field is disabled */
+    disabled: boolean;
+    /** A boolean value stating if the label should be rendered or not. This is useful for nested fields in arrays where
+     * you don't want to clutter the UI
+     */
+    displayLabel?: boolean;
+    /** The schema object for this field */
+    schema: RJSFSchema;
+    /** The uiSchema object for this field */
+    uiSchema?: UiSchema<T, F>;
+    /** The `formContext` object that was passed to `Form` */
+    formContext?: F;
+    /** The formData for this field */
+    formData: T;
+    /** The value change event handler; Can be called with a new value to change the value for this field */
+    onChange: (value: T) => void;
+    /** The key change event handler; Called when the key associated with a field is changed for an additionalProperty */
+    onKeyChange: (value: string) => () => void;
+    /** The property drop/removal event handler; Called when a field is removed in an additionalProperty context */
+    onDropPropertyClick: (value: string) => () => void;
+    /** The `registry` object */
+    registry: Registry<T, F>;
+};
+/** The properties that are passed to the `UnsupportedFieldTemplate` implementation */
+declare type UnsupportedFieldProps<T = any, F = any> = {
+    /** The schema object for this field */
+    schema: RJSFSchema;
+    /** The tree of unique ids for every child field */
+    idSchema?: IdSchema<T>;
+    /** The reason why the schema field has an unsupported type */
+    reason: string;
+    /** The `registry` object */
+    registry: Registry<T, F>;
+};
+/** The properties that are passed to a `TitleFieldTemplate` implementation */
+declare type TitleFieldProps<T = any, F = any> = {
+    /** The id of the field title in the hierarchy */
+    id: string;
+    /** The title for the field being rendered */
+    title: string;
+    /** The uiSchema object for this title field */
+    uiSchema?: UiSchema<T, F>;
+    /** A boolean value stating if the field is required */
+    required?: boolean;
+    /** The `registry` object */
+    registry: Registry<T, F>;
+};
+/** The properties that are passed to a `DescriptionFieldTemplate` implementation */
+declare type DescriptionFieldProps<T = any, F = any> = {
+    /** The id of the field description in the hierarchy */
+    id: string;
+    /** The description of the field being rendered */
+    description: string | React.ReactElement;
+    /** The `registry` object */
+    registry: Registry<T, F>;
+};
+/** The properties that are passed to a `ArrayFieldTitleTemplate` implementation */
+declare type ArrayFieldTitleProps<T = any, F = any> = Pick<TitleFieldProps<T, F>, "title" | "uiSchema" | "required" | "registry"> & {
+    /** The idSchema of the field in the hierarchy */
+    idSchema: IdSchema<T>;
+};
+/** The properties that are passed to a `ArrayFieldDescriptionTemplate` implementation */
+declare type ArrayFieldDescriptionProps<T = any, F = any> = Pick<DescriptionFieldProps<T, F>, "description" | "registry"> & {
+    /** The idSchema of the field in the hierarchy */
+    idSchema: IdSchema<T>;
+    /** The uiSchema object for this description field */
+    uiSchema?: UiSchema<T, F>;
+};
+/** The properties of each element in the ArrayFieldTemplateProps.items array */
+declare type ArrayFieldTemplateItemType<T = any, F = any> = {
+    /** The html for the item's content */
+    children: React.ReactElement;
+    /** The className string */
+    className: string;
+    /** A boolean value stating if the array item is disabled */
+    disabled: boolean;
+    /** A boolean value stating whether the array item can be moved down */
+    hasMoveDown: boolean;
+    /** A boolean value stating whether the array item can be moved up */
+    hasMoveUp: boolean;
+    /** A boolean value stating whether the array item can be removed */
+    hasRemove: boolean;
+    /** A boolean value stating whether the array item has a toolbar */
+    hasToolbar: boolean;
+    /** A number stating the index the array item occurs in `items` */
+    index: number;
+    /** Returns a function that adds a new item at `index` */
+    onAddIndexClick: (index: number) => (event?: any) => void;
+    /** Returns a function that removes the item at `index` */
+    onDropIndexClick: (index: number) => (event?: any) => void;
+    /** Returns a function that swaps the items at `index` with `newIndex` */
+    onReorderClick: (index: number, newIndex: number) => (event?: any) => void;
+    /** A boolean value stating if the array item is read-only */
+    readonly: boolean;
+    /** A stable, unique key for the array item */
+    key: string;
+    /** The `registry` object */
+    registry: Registry<T, F>;
+};
+/** The properties that are passed to an ArrayFieldTemplate implementation */
+declare type ArrayFieldTemplateProps<T = any, F = any> = {
+    /** A boolean value stating whether new elements can be added to the array */
+    canAdd?: boolean;
+    /** The className string */
+    className?: string;
+    /** A boolean value stating if the array is disabled */
+    disabled?: boolean;
+    /** An object containing the id for this object & ids for its properties */
+    idSchema: IdSchema<T>;
+    /** An array of objects representing the items in the array */
+    items: ArrayFieldTemplateItemType<T, F>[];
+    /** A function that adds a new item to the array */
+    onAddClick: (event?: any) => void;
+    /** A boolean value stating if the array is read-only */
+    readonly?: boolean;
+    /** A boolean value stating if the array is required */
+    required?: boolean;
+    /** A boolean value stating if the field is hiding its errors */
+    hideError?: boolean;
+    /** The schema object for this array */
+    schema: RJSFSchema;
+    /** The uiSchema object for this array field */
+    uiSchema?: UiSchema<T, F>;
+    /** A string value containing the title for the array */
+    title: string;
+    /** The `formContext` object that was passed to Form */
+    formContext?: F;
+    /** The formData for this array */
+    formData: T;
+    /** An array of strings listing all generated error messages from encountered errors for this widget */
+    rawErrors?: string[];
+    /** The `registry` object */
+    registry: Registry<T, F>;
+};
+/** The properties of each element in the ObjectFieldTemplateProps.properties array */
+declare type ObjectFieldTemplatePropertyType = {
+    /** The html for the property's content */
+    content: React.ReactElement;
+    /** A string representing the property name */
+    name: string;
+    /** A boolean value stating if the object property is disabled */
+    disabled: boolean;
+    /** A boolean value stating if the property is read-only */
+    readonly: boolean;
+    /** A boolean value stating if the property should be hidden */
+    hidden: boolean;
+};
+/** The properties that are passed to an ObjectFieldTemplate implementation */
+declare type ObjectFieldTemplateProps<T = any, F = any> = {
+    /** A string value containing the title for the object */
+    title: string;
+    /** A string value containing the description for the object */
+    description?: string;
+    /** A boolean value stating if the object is disabled */
+    disabled?: boolean;
+    /** An array of objects representing the properties in the object */
+    properties: ObjectFieldTemplatePropertyType[];
+    /** Returns a function that adds a new property to the object (to be used with additionalProperties) */
+    onAddClick: (schema: RJSFSchema) => () => void;
+    /** A boolean value stating if the object is read-only */
+    readonly?: boolean;
+    /** A boolean value stating if the object is required */
+    required?: boolean;
+    /** A boolean value stating if the field is hiding its errors */
+    hideError?: boolean;
+    /** The schema object for this object */
+    schema: RJSFSchema;
+    /** The uiSchema object for this object field */
+    uiSchema?: UiSchema<T, F>;
+    /** An object containing the id for this object & ids for its properties */
+    idSchema: IdSchema<T>;
+    /** The form data for the object */
+    formData: T;
+    /** The `formContext` object that was passed to Form */
+    formContext?: F;
+    /** The `registry` object */
+    registry: Registry<T, F>;
+};
+/** The properties that are passed to a Widget implementation */
+interface WidgetProps<T = any, F = any> extends GenericObjectType, Pick<React.HTMLAttributes<HTMLElement>, Exclude<keyof React.HTMLAttributes<HTMLElement>, "onBlur" | "onFocus">> {
+    /** The generated id for this widget */
+    id: string;
+    /** The JSONSchema subschema object for this widget */
+    schema: RJSFSchema;
+    /** The uiSchema for this widget */
+    uiSchema?: UiSchema<T, F>;
+    /** The current value for this widget */
+    value: any;
+    /** The required status of this widget */
+    required?: boolean;
+    /** A boolean value stating if the widget is disabled */
+    disabled?: boolean;
+    /** A boolean value stating if the widget is read-only */
+    readonly?: boolean;
+    /** A boolean value stating if the widget is hiding its errors */
+    hideError?: boolean;
+    /** A boolean value stating if the widget should autofocus */
+    autofocus?: boolean;
+    /** The placeholder for the widget, if any */
+    placeholder?: string;
+    /** A map of UI Options passed as a prop to the component, including the optional `enumOptions`
+     * which is a special case on top of `UIOptionsType` needed only by widgets
+     */
+    options: NonNullable<UIOptionsType<T, F>> & {
+        /** The enum options list for a type that supports them */
+        enumOptions?: EnumOptionsType[];
+    };
+    /** The `formContext` object that you passed to `Form` */
+    formContext?: F;
+    /** The input blur event handler; call it with the widget id and value */
+    onBlur: (id: string, value: any) => void;
+    /** The value change event handler; call it with the new value every time it changes */
+    onChange: (value: any) => void;
+    /** The input focus event handler; call it with the widget id and value */
+    onFocus: (id: string, value: any) => void;
+    /** The computed label for this widget, as a string */
+    label: string;
+    /** A boolean value stating if the widget can accept multiple values */
+    multiple?: boolean;
+    /** An array of strings listing all generated error messages from encountered errors for this widget */
+    rawErrors?: string[];
+    /** The `registry` object */
+    registry: Registry<T, F>;
+}
+/** The definition of a React-based Widget component */
+declare type Widget<T = any, F = any> = React.ComponentType<WidgetProps<T, F>>;
+/** The type that defines the props used by the Submit button */
+declare type SubmitButtonProps<T = any, F = any> = {
+    /** The uiSchema for this widget */
+    uiSchema?: UiSchema<T, F>;
+};
+/** The type that defines the props for an Icon button, extending from a basic HTML button attributes */
+declare type IconButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    /** An alternative specification for the type of the icon button */
+    iconType?: string;
+    /** The name representation or actual react element implementation for the icon */
+    icon?: string | React.ReactElement;
+};
+/** The type that defines how to change the behavior of the submit button for the form */
+declare type UISchemaSubmitButtonOptions = {
+    /** The text of the submit button. Set to "Submit" by default */
+    submitText?: string;
+    /** Flag, if `true`, removes the submit button completely from the form */
+    norender?: boolean;
+    /** Any other props to be passed to the submit button itself */
+    props?: GenericObjectType & {
+        /** A boolean value stating if the submit button is disabled */
+        disabled?: boolean;
+        /** The class name for the submit button */
+        className?: string;
+    };
+};
+/** This type represents an element used to render an enum option */
+declare type EnumOptionsType = {
+    /** The value for the enum option */
+    value: any;
+    /** The label for the enum options */
+    label: string;
+    /** The schema associated with the enum option when the option represents a `oneOf` or `anyOf` choice */
+    schema?: RJSFSchema;
+};
+/** This type remaps the keys of `Type` to prepend `ui:` onto them. As a result it does not need to be exported */
+declare type MakeUIType<Type> = {
+    [Property in keyof Type as `ui:${string & Property}`]: Type[Property];
+};
+/** This type represents all the known supported options in the `ui:options` property, kept separate in order to
+ * remap the keys. It also contains all the properties, optionally, of `TemplatesType` except "ButtonTemplates"
+ */
+declare type UIOptionsBaseType<T = any, F = any> = Partial<Omit<TemplatesType<T, F>, "ButtonTemplates">> & {
+    /** Any classnames that the user wants to be applied to a field in the ui */
+    classNames?: string;
+    /** We know that for title, it will be a string, if it is provided */
+    title?: string;
+    /** We know that for description, it will be a string, if it is provided */
+    description?: string;
+    /** We know that for placeholder, it will be a string, if it is provided */
+    placeholder?: string;
+    /** Used to add text next to a field to guide the end user in filling it in */
+    help?: string;
+    /** Flag, if set to `true`, will mark the field as automatically focused on a text input or textarea input */
+    autofocus?: boolean;
+    /** Use to mark the field as supporting auto complete on a text input or textarea input */
+    autocomplete?: HTMLInputElement["autocomplete"];
+    /** Flag, if set to `true`, will mark all child widgets from a given field as disabled */
+    disabled?: boolean;
+    /** The default value to use when an input for a field is empty */
+    emptyValue?: any;
+    /** Will disable any of the enum options specified in the array (by value) */
+    enumDisabled?: Array<string | number | boolean>;
+    /** Flag, if set to `true`, will hide the default error display for the given field AND all of its child fields in the
+     * hierarchy
+     */
+    hideError?: boolean;
+    /** Flag, if set to `true`, will mark all child widgets from a given field as read-only */
+    readonly?: boolean;
+    /** This property allows you to reorder the properties that are shown for a particular object */
+    order?: string[];
+    /** Flag, if set to `false`, will mark array fields as NOT being able to be added to (defaults to true) */
+    addable?: boolean;
+    /** Flag, if set to `false`, will mark array fields as NOT being able to be ordered (defaults to true) */
+    orderable?: boolean;
+    /** Flag, if set to `false`, will mark array fields as NOT being able to be removed (defaults to true) */
+    removable?: boolean;
+    /** Flag, if set to `true`, will mark a list of checkboxes as displayed all on one line instead of one per row */
+    inline?: boolean;
+    /** Used to change the input type (for example, `tel` or `email`) for an <input> */
+    inputType?: string;
+    /** Field labels are rendered by default. Labels may be omitted by setting the `label` option to `false` */
+    label?: boolean;
+    /** Provides a means to set the initial height of a textarea widget */
+    rows?: number;
+    /** If submitButtonOptions is provided it should match the `UISchemaSubmitButtonOptions` type */
+    submitButtonOptions?: UISchemaSubmitButtonOptions;
+    /** Allows RJSF to override the default widget implementation by specifying either the name of a widget that is used
+     * to look up an implementation from the `widgets` list or an actual one-off widget implementation itself
+     */
+    widget?: Widget<T, F> | string;
+    /** When using `additionalProperties`, key collision is prevented by appending a unique integer to the duplicate key.
+     * This option allows you to change the separator between the original key name and the integer. Default is "-"
+     */
+    duplicateKeySuffixSeparator?: string;
+};
+/** The type that represents the Options potentially provided by `ui:options` */
+declare type UIOptionsType<T = any, F = any> = UIOptionsBaseType<T, F> & {
+    /** Anything else will be one of these types */
+    [key: string]: boolean | number | string | object | any[] | null | undefined;
+};
+/** Type describing the well-known properties of the `UiSchema` while also supporting all user defined properties,
+ * starting with `ui:`.
+ */
+declare type UiSchema<T = any, F = any> = GenericObjectType & MakeUIType<UIOptionsBaseType<T, F>> & {
+    /** Allows the form to generate a unique prefix for the `Form`'s root prefix */
+    "ui:rootFieldId"?: string;
+    /** Allows RJSF to override the default field implementation by specifying either the name of a field that is used
+     * to look up an implementation from the `fields` list or an actual one-off `Field` component implementation itself
+     */
+    "ui:field"?: Field<T, F> | string;
+    /** An object that contains all of the potential UI options in a single object */
+    "ui:options"?: UIOptionsType<T, F>;
+};
+/** A `CustomValidator` function takes in a `formData` and `errors` object and returns the given `errors` object back,
+ * while potentially adding additional messages to the `errors`
+ */
+declare type CustomValidator<T = any> = (formData: T, errors: FormValidation<T>) => FormValidation<T>;
+/** An `ErrorTransformer` function will take in a list of `errors` and potentially return a transformation of those
+ * errors in what ever way it deems necessary
+ */
+declare type ErrorTransformer = (errors: RJSFValidationError[]) => RJSFValidationError[];
+/** The type that describes the data that is returned from the `ValidatorType.validateFormData()` function */
+declare type ValidationData<T> = {
+    /** The validation errors as a list of `RJSFValidationError` objects */
+    errors: RJSFValidationError[];
+    /** The validation errors in the form of an `ErrorSchema` */
+    errorSchema: ErrorSchema<T>;
+};
+/** The interface that describes the validation functions that are provided by a Validator implementation used by the
+ * schema utilities.
+ */
+interface ValidatorType<T = any> {
+    /** This function processes the `formData` with an optional user contributed `customValidate` function, which receives
+     * the form data and a `errorHandler` function that will be used to add custom validation errors for each field. Also
+     * supports a `transformErrors` function that will take the raw AJV validation errors, prior to custom validation and
+     * transform them in what ever way it chooses.
+     *
+     * @param formData - The form data to validate
+     * @param schema - The schema against which to validate the form data
+     * @param [customValidate] - An optional function that is used to perform custom validation
+     * @param [transformErrors] - An optional function that is used to transform errors after AJV validation
+     */
+    validateFormData(formData: T, schema: RJSFSchema, customValidate?: CustomValidator<T>, transformErrors?: ErrorTransformer): ValidationData<T>;
+    /** Converts an `errorSchema` into a list of `RJSFValidationErrors`
+     *
+     * @param errorSchema - The `ErrorSchema` instance to convert
+     * @param [fieldPath=[]] - The current field path, defaults to [] if not specified
+     */
+    toErrorList(errorSchema?: ErrorSchema<T>, fieldPath?: string[]): RJSFValidationError[];
+    /** Validates data against a schema, returning true if the data is valid, or
+     * false otherwise. If the schema is invalid, then this function will return
+     * false.
+     *
+     * @param schema - The schema against which to validate the form data   * @param schema
+     * @param formData- - The form data to validate
+     * @param rootSchema - The root schema used to provide $ref resolutions
+     */
+    isValid(schema: RJSFSchema, formData: T, rootSchema: RJSFSchema): boolean;
+}
+/** The `SchemaUtilsType` interface provides a wrapper around the publicly exported APIs in the `@rjsf/utils/schema`
+ * directory such that one does not have to explicitly pass the `validator` or `rootSchema` to each method. Since both
+ * the `validator` and `rootSchema` generally does not change across a `Form`, this allows for providing a simplified
+ * set of APIs to the `@rjsf/core` components and the various themes as well.
+ */
+interface SchemaUtilsType<T = any> {
+    /** Returns the `ValidatorType` in the `SchemaUtilsType`
+     *
+     * @returns - The `ValidatorType`
+     */
+    getValidator(): ValidatorType<T>;
+    /** Determines whether either the `validator` and `rootSchema` differ from the ones associated with this instance of
+     * the `SchemaUtilsType`. If either `validator` or `rootSchema` are falsy, then return false to prevent the creation
+     * of a new `SchemaUtilsType` with incomplete properties.
+     *
+     * @param validator - An implementation of the `ValidatorType` interface that will be compared against the current one
+     * @param rootSchema - The root schema that will be compared against the current one
+     * @returns - True if the `SchemaUtilsType` differs from the given `validator` or `rootSchema`
+     */
+    doesSchemaUtilsDiffer(validator: ValidatorType, rootSchema: RJSFSchema): boolean;
+    /** Returns the superset of `formData` that includes the given set updated to include any missing fields that have
+     * computed to have defaults provided in the `schema`.
+     *
+     * @param schema - The schema for which the default state is desired
+     * @param [formData] - The current formData, if any, onto which to provide any missing defaults
+     * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults
+     * @returns - The resulting `formData` with all the defaults provided
+     */
+    getDefaultFormState(schema: RJSFSchema, formData?: T, includeUndefinedValues?: boolean): T | T[] | undefined;
+    /** Determines whether the combination of `schema` and `uiSchema` properties indicates that the label for the `schema`
+     * should be displayed in a UI.
+     *
+     * @param schema - The schema for which the display label flag is desired
+     * @param [uiSchema] - The UI schema from which to derive potentially displayable information
+     * @returns - True if the label should be displayed or false if it should not
+     */
+    getDisplayLabel<F = any>(schema: RJSFSchema, uiSchema?: UiSchema<T, F>): boolean;
+    /** Given the `formData` and list of `options`, attempts to find the index of the option that best matches the data.
+     *
+     * @param formData - The current formData, if any, onto which to provide any missing defaults
+     * @param options - The list of options to find a matching options from
+     * @returns - The index of the matched option or 0 if none is available
+     */
+    getMatchingOption(formData: T, options: RJSFSchema[]): number;
+    /** Checks to see if the `schema` and `uiSchema` combination represents an array of files
+     *
+     * @param schema - The schema for which check for array of files flag is desired
+     * @param [uiSchema] - The UI schema from which to check the widget
+     * @returns - True if schema/uiSchema contains an array of files, otherwise false
+     */
+    isFilesArray<F = any>(schema: RJSFSchema, uiSchema?: UiSchema<T, F>): boolean;
+    /** Checks to see if the `schema` combination represents a multi-select
+     *
+     * @param schema - The schema for which check for a multi-select flag is desired
+     * @returns - True if schema contains a multi-select, otherwise false
+     */
+    isMultiSelect(schema: RJSFSchema): boolean;
+    /** Checks to see if the `schema` combination represents a select
+     *
+     * @param schema - The schema for which check for a select flag is desired
+     * @returns - True if schema contains a select, otherwise false
+     */
+    isSelect(schema: RJSFSchema): boolean;
+    /** Merges the errors in `additionalErrorSchema` into the existing `validationData` by combining the hierarchies in the
+     * two `ErrorSchema`s and then appending the error list from the `additionalErrorSchema` obtained by calling
+     * `validator.toErrorList()` onto the `errors` in the `validationData`. If no `additionalErrorSchema` is passed, then
+     * `validationData` is returned.
+     *
+     * @param validator - The validator used to convert an ErrorSchema to a list of errors
+     * @param validationData - The current `ValidationData` into which to merge the additional errors
+     * @param [additionalErrorSchema] - The additional set of errors
+     * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided.
+     */
+    mergeValidationData(validationData: ValidationData<T>, additionalErrorSchema?: ErrorSchema<T>): ValidationData<T>;
+    /** Retrieves an expanded schema that has had all of its conditions, additional properties, references and
+     * dependencies resolved and merged into the `schema` given a `rawFormData` that is used to do the potentially
+     * recursive resolution.
+     *
+     * @param schema - The schema for which retrieving a schema is desired
+     * @param [rawFormData] - The current formData, if any, to assist retrieving a schema
+     * @returns - The schema having its conditions, additional properties, references and dependencies resolved
+     */
+    retrieveSchema(schema: RJSFSchema, formData?: T): RJSFSchema;
+    /** Generates an `IdSchema` object for the `schema`, recursively
+     *
+     * @param schema - The schema for which the display label flag is desired
+     * @param [id] - The base id for the schema
+     * @param [formData] - The current formData, if any, onto which to provide any missing defaults
+     * @param [idPrefix='root'] - The prefix to use for the id
+     * @param [idSeparator='_'] - The separator to use for the path segments in the id
+     * @returns - The `IdSchema` object for the `schema`
+     */
+    toIdSchema(schema: RJSFSchema, id?: string, formData?: T, idPrefix?: string, idSeparator?: string): IdSchema<T>;
+    /** Generates an `PathSchema` object for the `schema`, recursively
+     *
+     * @param schema - The schema for which the display label flag is desired
+     * @param [name] - The base name for the schema
+     * @param [formData] - The current formData, if any, onto which to provide any missing defaults
+     * @returns - The `PathSchema` object for the `schema`
+     */
+    toPathSchema(schema: RJSFSchema, name?: string, formData?: T): PathSchema<T>;
+}
+
+/** Checks the schema to see if it is allowing additional items, by verifying that `schema.additionalItems` is an
+ * object. The user is warned in the console if `schema.additionalItems` has the value `true`.
+ *
+ * @param schema - The schema object to check
+ * @returns - True if additional items is allowed, otherwise false
+ */
+declare function allowAdditionalItems(schema: RJSFSchema): boolean;
+
+/** Attempts to convert the string into a number. If an empty string is provided, then `undefined` is returned. If a
+ * `null` is provided, it is returned. If the string ends in a `.` then the string is returned because the user may be
+ * in the middle of typing a float number. If a number ends in a pattern like `.0`, `.20`, `.030`, string is returned
+ * because the user may be typing number that will end in a non-zero digit. Otherwise, the string is wrapped by
+ * `Number()` and if that result is not `NaN`, that number will be returned, otherwise the string `value` will be.
+ *
+ * @param value - The string or null value to convert to a number
+ * @returns - The `value` converted to a number when appropriate, otherwise the `value`
+ */
+declare function asNumber(value: string | null): string | number | null | undefined;
+
+/** Checks whether the field described by `schema`, having the `uiSchema` and `formData` supports expanding. The UI for
+ * the field can expand if it has additional properties, is not forced as non-expandable by the `uiSchema` and the
+ * `formData` object doesn't already have `schema.maxProperties` elements.
+ *
+ * @param schema - The schema for the field that is being checked
+ * @param [uiSchema={}] - The uiSchema for the field
+ * @param [formData] - The formData for the field
+ * @returns - True if the schema element has additionalProperties, is expandable, and not at the maxProperties limit
+ */
+declare function canExpand<T = any, F = any>(schema: RJSFSchema, uiSchema?: UiSchema<T, F>, formData?: T): boolean;
+
+/** Creates a `SchemaUtilsType` interface that is based around the given `validator` and `rootSchema` parameters. The
+ * resulting interface implementation will forward the `validator` and `rootSchema` to all the wrapped APIs.
+ *
+ * @param validator - an implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @returns - An implementation of a `SchemaUtilsType` interface
+ */
+declare function createSchemaUtils<T = any>(validator: ValidatorType, rootSchema: RJSFSchema): SchemaUtilsType<T>;
+
+/** Given the `FileReader.readAsDataURL()` based `dataURI` extracts that data into an actual Blob along with the name
+ * of that Blob if provided in the URL. If no name is provided, then the name falls back to `unknown`.
+ *
+ * @param dataURI - The `DataUrl` potentially containing name and raw data to be converted to a Blob
+ * @returns - an object containing a Blob and its name, extracted from the URI
+ */
+declare function dataURItoBlob(dataURI: string): {
+    blob: Blob;
+    name: string;
+};
+
+/** Implements a deep equals using the `lodash.isEqualWith` function, that provides a customized comparator that
+ * assumes all functions are equivalent.
+ *
+ * @param a - The first element to compare
+ * @param b - The second element to compare
+ * @returns - True if the `a` and `b` are deeply equal, false otherwise
+ */
+declare function deepEquals(a: any, b: any): boolean;
+
+/** Given the name of a `$ref` from within a schema, using the `rootSchema`, look up and return the sub-schema using the
+ * path provided by that reference. If `#` is not the first character of the reference, or the path does not exist in
+ * the schema, then throw an Error. Otherwise return the sub-schema. Also deals with nested `$ref`s in the sub-schema.
+ *
+ * @param $ref - The ref string for which the schema definition is desired
+ * @param [rootSchema={}] - The root schema in which to search for the definition
+ * @returns - The sub-schema within the `rootSchema` which matches the `$ref` if it exists
+ * @throws - Error indicating that no schema for that reference exists
+ */
+declare function findSchemaDefinition($ref?: string, rootSchema?: RJSFSchema): RJSFSchema;
+
+/** Using the `schema`, `defaultType` and `options`, extract out the props for the <input> element that make sense.
+ *
+ * @param schema - The schema for the field provided by the widget
+ * @param [defaultType] - The default type, if any, for the field provided by the widget
+ * @param [options={}] - The UI Options for the field provided by the widget
+ * @param [autoDefaultStepAny=true] - Determines whether to auto-default step=any when the type is number and no step
+ * @returns - The extracted `InputPropsType` object
+ */
+declare function getInputProps<T = any, F = any>(schema: RJSFSchema, defaultType?: string, options?: UIOptionsType<T, F>, autoDefaultStepAny?: boolean): InputPropsType;
+
+/** Gets the type of a given `schema`. If the type is not explicitly defined, then an attempt is made to infer it from
+ * other elements of the schema as follows:
+ * - schema.const: Returns the `guessType()` of that value
+ * - schema.enum: Returns `string`
+ * - schema.properties: Returns `object`
+ * - schema.additionalProperties: Returns `object`
+ * - type is an array with a length of 2 and one type is 'null': Returns the other type
+ *
+ * @param schema - The schema for which to get the type
+ * @returns - The type of the schema
+ */
+declare function getSchemaType(schema: RJSFSchema): string | string[] | undefined;
+
+/** Extracts any `ui:submitButtonOptions` from the `uiSchema` and merges them onto the `DEFAULT_OPTIONS`
+ *
+ * @param [uiSchema={}] - the UI Schema from which to extract submit button props
+ * @returns - The merging of the `DEFAULT_OPTIONS` with any custom ones
+ */
+declare function getSubmitButtonOptions<T = any, F = any>(uiSchema?: UiSchema<T, F>): UISchemaSubmitButtonOptions;
+
+/** Returns the template with the given `name` from either the `uiSchema` if it is defined or from the `registry`
+ * otherwise. NOTE, since `ButtonTemplates` are not overridden in `uiSchema` only those in the `registry` are returned.
+ *
+ * @param name - The name of the template to fetch, restricted to the keys of `TemplatesType`
+ * @param registry - The `Registry` from which to read the template
+ * @param [uiOptions={}] - The `UIOptionsType` from which to read an alternate template
+ * @returns - The template from either the `uiSchema` or `registry` for the `name`
+ */
+declare function getTemplate<Name extends keyof TemplatesType<T, F>, T = any, F = any>(name: Name, registry: Registry<T, F>, uiOptions?: UIOptionsType<T, F>): TemplatesType<T, F>[Name];
+
+/** Get all passed options from ui:options, and ui:<optionName>, returning them in an object with the `ui:`
+ * stripped off.
+ *
+ * @param [uiSchema={}] - The UI Schema from which to get any `ui:xxx` options
+ * @returns - An object containing all of the `ui:xxx` options with the stripped off
+ */
+declare function getUiOptions<T = any, F = any>(uiSchema?: UiSchema<T, F>): UIOptionsType<T, F>;
+
+/** Given a schema representing a field to render and either the name or actual `Widget` implementation, returns the
+ * React component that is used to render the widget. If the `widget` is already a React component, then it is wrapped
+ * with a `MergedWidget`. Otherwise an attempt is made to look up the widget inside of the `registeredWidgets` map based
+ * on the schema type and `widget` name. If no widget component can be found an `Error` is thrown.
+ *
+ * @param schema - The schema for the field
+ * @param [widget] - Either the name of the widget OR a `Widget` implementation to use
+ * @param [registeredWidgets={}] - A registry of widget name to `Widget` implementation
+ * @returns - The `Widget` component to use
+ * @throws - An error if there is no `Widget` component that can be returned
+ */
+declare function getWidget<T = any, F = any>(schema: RJSFSchema, widget?: Widget<T, F> | string, registeredWidgets?: RegistryWidgetsType<T, F>): Widget<T, F>;
+
+/** Given a specific `value` attempts to guess the type of a schema element. In the case where we have to implicitly
+ *  create a schema, it is useful to know what type to use based on the data we are defining.
+ *
+ * @param value - The value from which to guess the type
+ * @returns - The best guess for the object type
+ */
+declare function guessType(value: any): "array" | "string" | "null" | "boolean" | "number" | "object";
+
+/** Detects whether the `widget` exists for the `schema` with the associated `registryWidgets` and returns true if it
+ * does, or false if it doesn't.
+ *
+ * @param schema - The schema for the field
+ * @param widget - Either the name of the widget OR a `Widget` implementation to use
+ * @param [registeredWidgets={}] - A registry of widget name to `Widget` implementation
+ * @returns - True if the widget exists, false otherwise
+ */
+declare function hasWidget<T = any, F = any>(schema: RJSFSchema, widget: Widget<T, F> | string, registeredWidgets?: RegistryWidgetsType<T, F>): boolean;
+
+/** This function checks if the given `schema` matches a single constant value. This happens when either the schema has
+ * an `enum` array with a single value or there is a `const` defined.
+ *
+ * @param schema - The schema for a field
+ * @returns - True if the `schema` has a single constant value, false otherwise
+ */
+declare function isConstant(schema: RJSFSchema): boolean;
+
+/** Checks to see if the `uiSchema` contains the `widget` field and that the widget is not `hidden`
+ *
+ * @param uiSchema - The UI Schema from which to detect if it is customized
+ * @returns - True if the `uiSchema` describes a custom widget, false otherwise
+ */
+declare function isCustomWidget<T = any, F = any>(uiSchema?: UiSchema<T, F>): boolean;
+
+/** Detects whether the given `schema` contains fixed items. This is the case when `schema.items` is a non-empty array
+ * that only contains objects.
+ *
+ * @param schema - The schema in which to check for fixed items
+ * @returns - True if there are fixed items in the schema, false otherwise
+ */
+declare function isFixedItems(schema: RJSFSchema): boolean;
+
+/** Determines whether a `thing` is an object for the purposes of RSJF. In this case, `thing` is an object if it has
+ * the type `object` but is NOT null, an array or a File.
+ *
+ * @param thing - The thing to check to see whether it is an object
+ * @returns - True if it is a non-null, non-array, non-File object
+ */
+declare function isObject(thing: any): boolean;
+
+/** Converts a local Date string into a UTC date string
+ *
+ * @param dateString - The string representation of a date as accepted by the `Date()` constructor
+ * @returns - A UTC date string if `dateString` is truthy, otherwise undefined
+ */
+declare function localToUTC(dateString: string): string | undefined;
+
+/** Merges the `defaults` object of type `T` into the `formData` of type `T`
+ *
+ * When merging defaults and form data, we want to merge in this specific way:
+ * - objects are deeply merged
+ * - arrays are merged in such a way that:
+ *   - when the array is set in form data, only array entries set in form data
+ *     are deeply merged; additional entries from the defaults are ignored
+ *   - when the array is not set in form data, the default is copied over
+ * - scalars are overwritten/set by form data
+ *
+ * @param defaults - The defaults to merge
+ * @param formData - The form data into which the defaults will be merged
+ * @returns - The resulting merged form data with defaults
+ */
+declare function mergeDefaultsWithFormData<T = any>(defaults: T, formData: T): T;
+
+/** Recursively merge deeply nested objects.
+ *
+ * @param obj1 - The first object to merge
+ * @param obj2 - The second object to merge
+ * @param [concatArrays=false] - Optional flag that, when true, will cause arrays to be concatenated
+ * @returns - A new object that is the merge of the two given objects
+ */
+declare function mergeObjects(obj1: GenericObjectType, obj2: GenericObjectType, concatArrays?: boolean): GenericObjectType;
+
+/** Recursively merge deeply nested schemas. The difference between `mergeSchemas` and `mergeObjects` is that
+ * `mergeSchemas` only concats arrays for values under the 'required' keyword, and when it does, it doesn't include
+ * duplicate values.
+ *
+ * @param obj1 - The first schema object to merge
+ * @param obj2 - The second schema object to merge
+ * @returns - The merged schema object
+ */
+declare function mergeSchemas(obj1: GenericObjectType, obj2: GenericObjectType): GenericObjectType;
+
+/** Gets the list of options from the schema. If the schema has an enum list, then those enum values are returned. The
+ * labels for the options will be extracted from the non-standard, RJSF-deprecated `enumNames` if it exists, otherwise
+ * the label will be the same as the `value`. If the schema has a `oneOf` or `anyOf`, then the value is the list of
+ * `const` values from the schema and the label is either the `schema.title` or the value.
+ *
+ * @param schema - The schema from which to extract the options list
+ * @returns - The list of options from the schema
+ */
+declare function optionsList(schema: RJSFSchema): EnumOptionsType[] | undefined;
+
+/** Given a list of `properties` and an `order` list, returns a list that contains the `properties` ordered correctly.
+ * If `order` is not an array, then the untouched `properties` list is returned. Otherwise `properties` is ordered per
+ * the `order` list. If `order` contains a '*' then any `properties` that are not mentioned explicity in `order` will be
+ * places in the location of the `*`.
+ *
+ * @param properties - The list of property keys to be ordered
+ * @param order - An array of property keys to be ordered first, with an optional '*' property
+ * @returns - A list with the `properties` ordered
+ * @throws - Error when the properties cannot be ordered correctly
+ */
+declare function orderProperties(properties: string[], order?: string[]): string[];
+
+/** Returns a string representation of the `num` that is padded with leading "0"s if necessary
+ *
+ * @param num - The number to pad
+ * @param width - The width of the string at which no lead padding is necessary
+ * @returns - The number converted to a string with leading zero padding if the number of digits is less than `width`
+ */
+declare function pad(num: number, width: number): string;
+
+/** Parses the `dateString` into a `DateObject`, including the time information when `includeTime` is true
+ *
+ * @param dateString - The date string to parse into a DateObject
+ * @param [includeTime=true] - Optional flag, if false, will not include the time data into the object
+ * @returns - The date string converted to a `DateObject`
+ * @throws - Error when the date cannot be parsed from the string
+ */
+declare function parseDateString(dateString?: string, includeTime?: boolean): DateObject;
+
+/** Returns the real value for a select widget due to a silly limitation in the DOM which causes option change event
+ * values to always be retrieved as strings. Uses the `schema` to help determine the value's true type. If the value is
+ * an empty string, then the `emptyValue` from the `options` is returned, falling back to undefined.
+ *
+ * @param schema - The schema to used to determine the value's true type
+ * @param [value] - The value to convert
+ * @param [options] - The UIOptionsType from which to potentially extract the emptyValue
+ * @returns - The `value` converted to the proper type
+ */
+declare function processSelectValue<T = any, F = any>(schema: RJSFSchema, value?: any, options?: UIOptionsType<T, F>): any;
+
+/** Extracts the range spec information `{ step?: number, min?: number, max?: number }` that can be spread onto an HTML
+ * input from the range analog in the schema `{ multipleOf?: number, minimum?: number, maximum?: number }`.
+ *
+ * @param schema - The schema from which to extract the range spec
+ * @returns - A range specification from the schema
+ */
+declare function rangeSpec(schema: RJSFSchema): RangeSpecType;
+
+/** Check to see if a `schema` specifies that a value must be true. This happens when:
+ * - `schema.const` is truthy
+ * - `schema.enum` == `[true]`
+ * - `schema.anyOf` or `schema.oneOf` has a single value which recursively returns true
+ * - `schema.allOf` has at least one value which recursively returns true
+ *
+ * @param schema - The schema to check
+ * @returns - True if the schema specifies a value that must be true, false otherwise
+ */
+declare function schemaRequiresTrueValue(schema: RJSFSchema): boolean;
+
+/** Determines whether the given `component` should be rerendered by comparing its current set of props and state
+ * against the next set. If either of those two sets are not the same, then the component should be rerendered.
+ *
+ * @param component - A React component being checked
+ * @param nextProps - The next set of props against which to check
+ * @param nextState - The next set of state against which to check
+ * @returns - True if the component should be re-rendered, false otherwise
+ */
+declare function shouldRender(component: React.Component, nextProps: any, nextState: any): boolean;
+
+/** Returns the constant value from the schema when it is either a single value enum or has a const key. Otherwise
+ * throws an error.
+ *
+ * @param schema - The schema from which to obtain the constant value
+ * @returns - The constant value for the schema
+ * @throws - Error when the schema does not have a constant value
+ */
+declare function toConstant(schema: RJSFSchema): json_schema.JSONSchema7Type | undefined;
+
+/** Returns a UTC date string for the given `dateObject`. If `time` is false, then the time portion of the string is
+ * removed.
+ *
+ * @param dateObject - The `DateObject` to convert to a date string
+ * @param [time=true] - Optional flag used to remove the time portion of the date string if false
+ * @returns - The UTC date string
+ */
+declare function toDateString(dateObject: DateObject, time?: boolean): string;
+
+/** Converts a UTC date string into a local Date format
+ *
+ * @param jsonDate - A UTC date string
+ * @returns - An empty string when `jsonDate` is falsey, otherwise a date string in local format
+ */
+declare function utcToLocal(jsonDate: string): string;
+
+/** Below are the list of all the keys into various elements of a RJSFSchema or UiSchema that are used by the various
+ * utility functions. In addition to those keys, there are the special `ADDITIONAL_PROPERTY_FLAG` and
+ * `RJSF_ADDITONAL_PROPERTIES_FLAG` flags that is added to a schema under certain conditions by the `retrieveSchema()`
+ * utility.
+ */
+declare const ADDITIONAL_PROPERTY_FLAG = "__additional_property";
+declare const ADDITIONAL_PROPERTIES_KEY = "additionalProperties";
+declare const ALL_OF_KEY = "allOf";
+declare const ANY_OF_KEY = "anyOf";
+declare const CONST_KEY = "const";
+declare const DEFAULT_KEY = "default";
+declare const DEFINITIONS_KEY = "definitions";
+declare const DEPENDENCIES_KEY = "dependencies";
+declare const ENUM_KEY = "enum";
+declare const ERRORS_KEY = "__errors";
+declare const ID_KEY = "$id";
+declare const ITEMS_KEY = "items";
+declare const NAME_KEY = "$name";
+declare const ONE_OF_KEY = "oneOf";
+declare const PROPERTIES_KEY = "properties";
+declare const REQUIRED_KEY = "required";
+declare const SUBMIT_BTN_OPTIONS_KEY = "submitButtonOptions";
+declare const REF_KEY = "$ref";
+declare const RJSF_ADDITONAL_PROPERTIES_FLAG = "__rjsf_additionalProperties";
+declare const UI_FIELD_KEY = "ui:field";
+declare const UI_WIDGET_KEY = "ui:widget";
+declare const UI_OPTIONS_KEY = "ui:options";
+
+/** Returns the superset of `formData` that includes the given set updated to include any missing fields that have
+ * computed to have defaults provided in the `schema`.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param theSchema - The schema for which the default state is desired
+ * @param [formData] - The current formData, if any, onto which to provide any missing defaults
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults
+ * @returns - The resulting `formData` with all the defaults provided
+ */
+declare function getDefaultFormState<T = any>(validator: ValidatorType, theSchema: RJSFSchema, formData?: T, rootSchema?: RJSFSchema, includeUndefinedValues?: boolean): T | T[] | undefined;
+
+/** Determines whether the combination of `schema` and `uiSchema` properties indicates that the label for the `schema`
+ * should be displayed in a UI.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which the display label flag is desired
+ * @param [uiSchema={}] - The UI schema from which to derive potentially displayable information
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @returns - True if the label should be displayed or false if it should not
+ */
+declare function getDisplayLabel<T = any, F = any>(validator: ValidatorType, schema: RJSFSchema, uiSchema?: UiSchema<T, F>, rootSchema?: RJSFSchema): boolean;
+
+/** Given the `formData` and list of `options`, attempts to find the index of the option that best matches the data.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param formData - The current formData, if any, used to figure out a match
+ * @param options - The list of options to find a matching options from
+ * @param rootSchema - The root schema, used to primarily to look up `$ref`s
+ * @returns - The index of the matched option or 0 if none is available
+ */
+declare function getMatchingOption<T = any>(validator: ValidatorType, formData: T | undefined, options: RJSFSchema[], rootSchema: RJSFSchema): number;
+
+/** Checks to see if the `schema` and `uiSchema` combination represents an array of files
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which check for array of files flag is desired
+ * @param [uiSchema={}] - The UI schema from which to check the widget
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @returns - True if schema/uiSchema contains an array of files, otherwise false
+ */
+declare function isFilesArray<T = any, F = any>(validator: ValidatorType, schema: RJSFSchema, uiSchema?: UiSchema<T, F>, rootSchema?: RJSFSchema): boolean;
+
+/** Checks to see if the `schema` combination represents a multi-select
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which check for a multi-select flag is desired
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @returns - True if schema contains a multi-select, otherwise false
+ */
+declare function isMultiSelect<T = any>(validator: ValidatorType, schema: RJSFSchema, rootSchema?: RJSFSchema): boolean;
+
+/** Checks to see if the `schema` combination represents a select
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param theSchema - The schema for which check for a select flag is desired
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @returns - True if schema contains a select, otherwise false
+ */
+declare function isSelect<T = any>(validator: ValidatorType, theSchema: RJSFSchema, rootSchema?: RJSFSchema): boolean;
+
+/** Merges the errors in `additionalErrorSchema` into the existing `validationData` by combining the hierarchies in the
+ * two `ErrorSchema`s and then appending the error list from the `additionalErrorSchema` obtained by calling
+ * `validator.toErrorList()` onto the `errors` in the `validationData`. If no `additionalErrorSchema` is passed, then
+ * `validationData` is returned.
+ *
+ * @param validator - The validator used to convert an ErrorSchema to a list of errors
+ * @param validationData - The current `ValidationData` into which to merge the additional errors
+ * @param [additionalErrorSchema] - The additional set of errors in an `ErrorSchema`
+ * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided.
+ */
+declare function mergeValidationData<T = any>(validator: ValidatorType<T>, validationData: ValidationData<T>, additionalErrorSchema?: ErrorSchema<T>): ValidationData<T>;
+
+/** Retrieves an expanded schema that has had all of its conditions, additional properties, references and dependencies
+ * resolved and merged into the `schema` given a `validator`, `rootSchema` and `rawFormData` that is used to do the
+ * potentially recursive resolution.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param schema - The schema for which retrieving a schema is desired
+ * @param [rootSchema={}] - The root schema that will be forwarded to all the APIs
+ * @param [rawFormData] - The current formData, if any, to assist retrieving a schema
+ * @returns - The schema having its conditions, additional properties, references and dependencies resolved
+ */
+declare function retrieveSchema<T = any>(validator: ValidatorType, schema: RJSFSchema, rootSchema?: RJSFSchema, rawFormData?: T): RJSFSchema;
+
+/** Generates an `IdSchema` object for the `schema`, recursively
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which the `IdSchema` is desired
+ * @param [id] - The base id for the schema
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @param [formData] - The current formData, if any, to assist retrieving a schema
+ * @param [idPrefix='root'] - The prefix to use for the id
+ * @param [idSeparator='_'] - The separator to use for the path segments in the id
+ * @returns - The `IdSchema` object for the `schema`
+ */
+declare function toIdSchema<T = any>(validator: ValidatorType, schema: RJSFSchema, id?: string | null, rootSchema?: RJSFSchema, formData?: T, idPrefix?: string, idSeparator?: string): IdSchema<T>;
+
+/** Generates an `PathSchema` object for the `schema`, recursively
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which the `PathSchema` is desired
+ * @param [name=''] - The base name for the schema
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @param [formData] - The current formData, if any, to assist retrieving a schema
+ * @returns - The `PathSchema` object for the `schema`
+ */
+declare function toPathSchema<T = any>(validator: ValidatorType, schema: RJSFSchema, name?: string, rootSchema?: RJSFSchema, formData?: T): PathSchema<T>;
+
+export { ADDITIONAL_PROPERTIES_KEY, ADDITIONAL_PROPERTY_FLAG, ALL_OF_KEY, ANY_OF_KEY, ArrayFieldDescriptionProps, ArrayFieldTemplateItemType, ArrayFieldTemplateProps, ArrayFieldTitleProps, CONST_KEY, CustomValidator, DEFAULT_KEY, DEFINITIONS_KEY, DEPENDENCIES_KEY, DateObject, DescriptionFieldProps, ENUM_KEY, ERRORS_KEY, EnumOptionsType, ErrorListProps, ErrorSchema, ErrorTransformer, Field, FieldError, FieldErrors, FieldId, FieldPath, FieldProps, FieldTemplateProps, FieldValidation, FormValidation, GenericObjectType, ID_KEY, ITEMS_KEY, IconButtonProps, IdSchema, InputPropsType, NAME_KEY, ONE_OF_KEY, ObjectFieldTemplatePropertyType, ObjectFieldTemplateProps, PROPERTIES_KEY, PathSchema, REF_KEY, REQUIRED_KEY, RJSFSchema, RJSFSchemaDefinition, RJSFValidationError, RJSF_ADDITONAL_PROPERTIES_FLAG, RangeSpecType, Registry, RegistryFieldsType, RegistryWidgetsType, SUBMIT_BTN_OPTIONS_KEY, SchemaUtilsType, SubmitButtonProps, TemplatesType, TitleFieldProps, UIOptionsType, UISchemaSubmitButtonOptions, UI_FIELD_KEY, UI_OPTIONS_KEY, UI_WIDGET_KEY, UiSchema, UnsupportedFieldProps, ValidationData, ValidatorType, Widget, WidgetProps, allowAdditionalItems, asNumber, canExpand, createSchemaUtils, dataURItoBlob, deepEquals, findSchemaDefinition, getDefaultFormState, getDisplayLabel, getInputProps, getMatchingOption, getSchemaType, getSubmitButtonOptions, getTemplate, getUiOptions, getWidget, guessType, hasWidget, isConstant, isCustomWidget, isFilesArray, isFixedItems, isMultiSelect, isObject, isSelect, localToUTC, mergeDefaultsWithFormData, mergeObjects, mergeSchemas, mergeValidationData, optionsList, orderProperties, pad, parseDateString, processSelectValue, rangeSpec, retrieveSchema, schemaRequiresTrueValue, shouldRender, toConstant, toDateString, toIdSchema, toPathSchema, utcToLocal };