@rjsf/utils 5.0.0-beta.8 → 5.0.0

package/dist/index.d.ts

@@ -1,21 +1,23 @@
-import React from 'react';
+import React, { StyleHTMLAttributes } from 'react';
 import * as json_schema from 'json-schema';
-import { JSONSchema7, JSONSchema7Definition } from 'json-schema';
+import { JSONSchema7 } 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 = {
+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.
+/** Map the JSONSchema7 to our own type so that we can easily bump to a more recent version 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.
+type StrictRJSFSchema = JSONSchema7;
+/** Allow for more flexible schemas (i.e. draft-2019) than the strict JSONSchema7
  */
-declare type RJSFSchemaDefinition = JSONSchema7Definition;
+type RJSFSchema = StrictRJSFSchema & GenericObjectType;
+/** Alias GenericObjectType as FormContextType to allow us to remap this at some future date
+ */
+type FormContextType = GenericObjectType;
 /** The interface representing a Date object that contains an optional time */
 interface DateObject {
     /** The year of the Date */
@@ -32,7 +34,7 @@ interface DateObject {
     second?: number;
 }
 /** Properties describing a Range specification in terms of attribute that can be added to the `HTML` `<input>` */
-declare type RangeSpecType = {
+type RangeSpecType = {
     /** Specifies the interval between legal numbers in an input field */
     step?: number;
     /** Specifies a minimum value for an <input> element */
@@ -41,7 +43,7 @@ declare type RangeSpecType = {
     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"> & {
+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" */
@@ -50,25 +52,25 @@ declare type InputPropsType = Omit<RangeSpecType, "step"> & {
     autoComplete?: HTMLInputElement["autocomplete"];
 };
 /** Type describing an id used for a field in the `IdSchema` */
-declare type FieldId = {
+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 & {
+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 = {
+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 & {
+type PathSchema<T = any> = FieldPath & {
     [key in keyof T]?: PathSchema<T[key]>;
 };
 /** The type for error produced by RJSF schema validation */
-declare type RJSFValidationError = {
+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" */
@@ -90,27 +92,27 @@ declare type RJSFValidationError = {
     stack: string;
 };
 /** The type that describes an error in a field */
-declare type FieldError = string;
+type FieldError = string;
 /** The type that describes the list of errors for a field */
-declare type FieldErrors = {
+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 & {
+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 & {
+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 & {
+type FormValidation<T = any> = FieldValidation & {
     [key in keyof T]?: FormValidation<T[key]>;
 };
 /** The properties that are passed to an `ErrorListTemplate` implementation */
-declare type ErrorListProps<T = any, F = any> = {
+type ErrorListProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = {
     /** The errorSchema constructed by `Form` */
     errorSchema: ErrorSchema<T>;
     /** An array of the errors */
@@ -118,131 +120,133 @@ declare type ErrorListProps<T = any, F = any> = {
     /** The `formContext` object that was passed to `Form` */
     formContext?: F;
     /** The schema that was passed to `Form` */
-    schema: RJSFSchema;
+    schema: S;
     /** The uiSchema that was passed to `Form` */
-    uiSchema?: UiSchema<T, F>;
+    uiSchema?: UiSchema<T, S, F>;
 };
 /** The properties that are passed to an `FieldErrorTemplate` implementation */
-declare type FieldErrorProps<T = any, F = any> = {
+type FieldErrorProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = {
     /** The errorSchema constructed by `Form` */
     errorSchema?: ErrorSchema<T>;
     /** An array of the errors */
-    errors?: string[];
+    errors?: Array<string | React.ReactElement>;
     /** The tree of unique ids for every child field */
     idSchema: IdSchema<T>;
     /** The schema that was passed to field */
-    schema: RJSFSchema;
+    schema: S;
     /** The uiSchema that was passed to field */
-    uiSchema?: UiSchema<T, F>;
+    uiSchema?: UiSchema<T, S, F>;
     /** The `registry` object */
-    registry: Registry<T, F>;
+    registry: Registry<T, S, F>;
 };
 /** The properties that are passed to an `FieldHelpTemplate` implementation */
-declare type FieldHelpProps<T = any, F = any> = {
+type FieldHelpProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = {
     /** The help information to be rendered */
     help?: string | React.ReactElement;
     /** The tree of unique ids for every child field */
     idSchema: IdSchema<T>;
     /** The schema that was passed to field */
-    schema: RJSFSchema;
+    schema: S;
     /** The uiSchema that was passed to field */
-    uiSchema?: UiSchema<T, F>;
+    uiSchema?: UiSchema<T, S, F>;
     /** Flag indicating whether there are errors associated with this field */
     hasErrors?: boolean;
     /** The `registry` object */
-    registry: Registry<T, F>;
+    registry: Registry<T, S, F>;
 };
 /** The set of `Fields` stored in the `Registry` */
-declare type RegistryFieldsType<T = any, F = any> = {
+type RegistryFieldsType<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = {
     /** A `Field` indexed by `name` */
-    [name: string]: Field<T, F>;
+    [name: string]: Field<T, S, F>;
 };
 /** The set of `Widgets` stored in the `Registry` */
-declare type RegistryWidgetsType<T = any, F = any> = {
+type RegistryWidgetsType<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = {
     /** A `Widget` indexed by `name` */
-    [name: string]: Widget<T, F>;
+    [name: string]: Widget<T, S, F>;
 };
 /** The set of RJSF templates that can be overridden by themes or users */
-interface TemplatesType<T = any, F = any> {
+interface TemplatesType<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> {
     /** The template to use while rendering normal or fixed array fields */
-    ArrayFieldTemplate: React.ComponentType<ArrayFieldTemplateProps<T, F>>;
+    ArrayFieldTemplate: React.ComponentType<ArrayFieldTemplateProps<T, S, F>>;
     /** The template to use while rendering the description for an array field */
-    ArrayFieldDescriptionTemplate: React.ComponentType<ArrayFieldDescriptionProps<T, F>>;
+    ArrayFieldDescriptionTemplate: React.ComponentType<ArrayFieldDescriptionProps<T, S, F>>;
     /** The template to use while rendering an item in an array field */
-    ArrayFieldItemTemplate: React.ComponentType<ArrayFieldTemplateItemType<T, F>>;
+    ArrayFieldItemTemplate: React.ComponentType<ArrayFieldTemplateItemType<T, S, F>>;
     /** The template to use while rendering the title for an array field */
-    ArrayFieldTitleTemplate: React.ComponentType<ArrayFieldTitleProps<T, F>>;
+    ArrayFieldTitleTemplate: React.ComponentType<ArrayFieldTitleProps<T, S, F>>;
     /** The template to use while rendering the standard html input */
-    BaseInputTemplate: React.ComponentType<WidgetProps<T, F>>;
+    BaseInputTemplate: React.ComponentType<WidgetProps<T, S, F>>;
     /** The template to use for rendering the description of a field */
-    DescriptionFieldTemplate: React.ComponentType<DescriptionFieldProps<T, F>>;
+    DescriptionFieldTemplate: React.ComponentType<DescriptionFieldProps<T, S, F>>;
     /** The template to use while rendering the errors for the whole form */
-    ErrorListTemplate: React.ComponentType<ErrorListProps<T, F>>;
+    ErrorListTemplate: React.ComponentType<ErrorListProps<T, S, F>>;
     /** The template to use while rendering the errors for a single field */
-    FieldErrorTemplate: React.ComponentType<FieldErrorProps<T, F>>;
+    FieldErrorTemplate: React.ComponentType<FieldErrorProps<T, S, F>>;
     /** The template to use while rendering the errors for a single field */
-    FieldHelpTemplate: React.ComponentType<FieldHelpProps<T, F>>;
+    FieldHelpTemplate: React.ComponentType<FieldHelpProps<T, S, F>>;
     /** The template to use while rendering a field */
-    FieldTemplate: React.ComponentType<FieldTemplateProps<T, F>>;
+    FieldTemplate: React.ComponentType<FieldTemplateProps<T, S, F>>;
     /** The template to use while rendering an object */
-    ObjectFieldTemplate: React.ComponentType<ObjectFieldTemplateProps<T, F>>;
+    ObjectFieldTemplate: React.ComponentType<ObjectFieldTemplateProps<T, S, F>>;
     /** The template to use for rendering the title of a field */
-    TitleFieldTemplate: React.ComponentType<TitleFieldProps<T, F>>;
+    TitleFieldTemplate: React.ComponentType<TitleFieldProps<T, S, F>>;
     /** The template to use for rendering information about an unsupported field type in the schema */
-    UnsupportedFieldTemplate: React.ComponentType<UnsupportedFieldProps<T, F>>;
+    UnsupportedFieldTemplate: React.ComponentType<UnsupportedFieldProps<T, S, F>>;
+    /** The template to use for rendering a field that allows a user to add additional properties */
+    WrapIfAdditionalTemplate: React.ComponentType<WrapIfAdditionalTemplateProps<T, S, 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>>;
+        SubmitButton: React.ComponentType<SubmitButtonProps<T, S, F>>;
         /** The template to use for the Add button used for AdditionalProperties and Array items */
-        AddButton: React.ComponentType<IconButtonProps>;
+        AddButton: React.ComponentType<IconButtonProps<T, S, F>>;
         /** The template to use for the Move Down button used for Array items */
-        MoveDownButton: React.ComponentType<IconButtonProps>;
+        MoveDownButton: React.ComponentType<IconButtonProps<T, S, F>>;
         /** The template to use for the Move Up button used for Array items */
-        MoveUpButton: React.ComponentType<IconButtonProps>;
+        MoveUpButton: React.ComponentType<IconButtonProps<T, S, F>>;
         /** The template to use for the Remove button used for AdditionalProperties and Array items */
-        RemoveButton: React.ComponentType<IconButtonProps>;
+        RemoveButton: React.ComponentType<IconButtonProps<T, S, F>>;
     };
 }
 /** 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> {
+interface Registry<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = 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>;
+    fields: RegistryFieldsType<T, S, 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>;
+    templates: TemplatesType<T, S, 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>;
+    widgets: RegistryWidgetsType<T, S, 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;
+    rootSchema: S;
     /** 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>;
+    schemaUtils: SchemaUtilsType<T, S>;
 }
 /** 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">> {
+interface FieldProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> extends GenericObjectType, Pick<React.HTMLAttributes<HTMLElement>, Exclude<keyof React.HTMLAttributes<HTMLElement>, "onBlur" | "onFocus" | "onChange">> {
     /** The JSON subschema object for this field */
-    schema: RJSFSchema;
+    schema: S;
     /** The uiSchema for this field */
-    uiSchema?: UiSchema<T, F>;
+    uiSchema?: UiSchema<T, S, F>;
     /** The tree of unique ids for every child field */
     idSchema: IdSchema<T>;
     /** The data for this field */
-    formData: T;
+    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;
+    onChange: (newFormData: T | undefined, es?: ErrorSchema<T>, id?: string) => 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 */
@@ -262,16 +266,18 @@ interface FieldProps<T = any, F = any> extends GenericObjectType, Pick<React.HTM
     /** 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>;
+    registry: Registry<T, S, F>;
 }
 /** The definition of a React-based Field component */
-declare type Field<T = any, F = any> = React.ComponentType<FieldProps<T, F>>;
+type Field<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = React.ComponentType<FieldProps<T, S, F>>;
 /** The properties that are passed to a FieldTemplate implementation */
-declare type FieldTemplateProps<T = any, F = any> = {
+type FieldTemplateProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = 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;
+    /** An object containing the style as defined in the `uiSchema` */
+    style?: StyleHTMLAttributes<any>;
     /** 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
@@ -307,75 +313,85 @@ declare type FieldTemplateProps<T = any, F = any> = {
      */
     displayLabel?: boolean;
     /** The schema object for this field */
-    schema: RJSFSchema;
+    schema: S;
     /** The uiSchema object for this field */
-    uiSchema?: UiSchema<T, F>;
+    uiSchema?: UiSchema<T, S, F>;
     /** The `formContext` object that was passed to `Form` */
     formContext?: F;
     /** The formData for this field */
-    formData: T;
+    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;
+    onChange: FieldProps["onChange"];
     /** 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>;
+    registry: Registry<T, S, F>;
 };
 /** The properties that are passed to the `UnsupportedFieldTemplate` implementation */
-declare type UnsupportedFieldProps<T = any, F = any> = {
+type UnsupportedFieldProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = {
     /** The schema object for this field */
-    schema: RJSFSchema;
+    schema: S;
     /** 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>;
+    registry: Registry<T, S, F>;
 };
 /** The properties that are passed to a `TitleFieldTemplate` implementation */
-declare type TitleFieldProps<T = any, F = any> = {
+type TitleFieldProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = {
     /** The id of the field title in the hierarchy */
     id: string;
     /** The title for the field being rendered */
     title: string;
+    /** The schema object for the field being titled */
+    schema: S;
     /** The uiSchema object for this title field */
-    uiSchema?: UiSchema<T, F>;
+    uiSchema?: UiSchema<T, S, F>;
     /** A boolean value stating if the field is required */
     required?: boolean;
     /** The `registry` object */
-    registry: Registry<T, F>;
+    registry: Registry<T, S, F>;
 };
 /** The properties that are passed to a `DescriptionFieldTemplate` implementation */
-declare type DescriptionFieldProps<T = any, F = any> = {
+type DescriptionFieldProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = {
     /** The id of the field description in the hierarchy */
     id: string;
+    /** The schema object for the field being described */
+    schema: S;
+    /** The uiSchema object for this description field */
+    uiSchema?: UiSchema<T, S, F>;
     /** The description of the field being rendered */
     description: string | React.ReactElement;
     /** The `registry` object */
-    registry: Registry<T, F>;
+    registry: Registry<T, S, 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"> & {
+type ArrayFieldTitleProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = Omit<TitleFieldProps<T, S, F>, "id" | "title"> & {
+    /** The title for the field being rendered */
+    title?: string;
     /** 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"> & {
+type ArrayFieldDescriptionProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = Omit<DescriptionFieldProps<T, S, F>, "id" | "description"> & {
+    /** The description of the field being rendered */
+    description?: string | React.ReactElement;
     /** 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> = {
+type ArrayFieldTemplateItemType<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = 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 new items can be added to the array */
+    canAdd: 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 */
@@ -386,6 +402,8 @@ declare type ArrayFieldTemplateItemType<T = any, F = any> = {
     hasToolbar: boolean;
     /** A number stating the index the array item occurs in `items` */
     index: number;
+    /** A number stating the total number `items` in the array */
+    totalItems: 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` */
@@ -396,11 +414,15 @@ declare type ArrayFieldTemplateItemType<T = any, F = any> = {
     readonly: boolean;
     /** A stable, unique key for the array item */
     key: string;
+    /** The schema object for this array item */
+    schema: S;
+    /** The uiSchema object for this array item */
+    uiSchema?: UiSchema<T, S, F>;
     /** The `registry` object */
-    registry: Registry<T, F>;
+    registry: Registry<T, S, F>;
 };
 /** The properties that are passed to an ArrayFieldTemplate implementation */
-declare type ArrayFieldTemplateProps<T = any, F = any> = {
+type ArrayFieldTemplateProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = {
     /** A boolean value stating whether new elements can be added to the array */
     canAdd?: boolean;
     /** The className string */
@@ -410,7 +432,7 @@ declare type ArrayFieldTemplateProps<T = any, F = any> = {
     /** 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>[];
+    items: ArrayFieldTemplateItemType<T, S, 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 */
@@ -420,22 +442,22 @@ declare type ArrayFieldTemplateProps<T = any, F = any> = {
     /** A boolean value stating if the field is hiding its errors */
     hideError?: boolean;
     /** The schema object for this array */
-    schema: RJSFSchema;
+    schema: S;
     /** The uiSchema object for this array field */
-    uiSchema?: UiSchema<T, F>;
+    uiSchema?: UiSchema<T, S, 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;
+    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>;
+    registry: Registry<T, S, F>;
 };
 /** The properties of each element in the ObjectFieldTemplateProps.properties array */
-declare type ObjectFieldTemplatePropertyType = {
+type ObjectFieldTemplatePropertyType = {
     /** The html for the property's content */
     content: React.ReactElement;
     /** A string representing the property name */
@@ -448,7 +470,7 @@ declare type ObjectFieldTemplatePropertyType = {
     hidden: boolean;
 };
 /** The properties that are passed to an ObjectFieldTemplate implementation */
-declare type ObjectFieldTemplateProps<T = any, F = any> = {
+type ObjectFieldTemplateProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = {
     /** A string value containing the title for the object */
     title: string;
     /** A string value containing the description for the object */
@@ -458,7 +480,7 @@ declare type ObjectFieldTemplateProps<T = any, F = any> = {
     /** 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;
+    onAddClick: (schema: S) => () => void;
     /** A boolean value stating if the object is read-only */
     readonly?: boolean;
     /** A boolean value stating if the object is required */
@@ -466,26 +488,31 @@ declare type ObjectFieldTemplateProps<T = any, F = any> = {
     /** A boolean value stating if the field is hiding its errors */
     hideError?: boolean;
     /** The schema object for this object */
-    schema: RJSFSchema;
+    schema: S;
     /** The uiSchema object for this object field */
-    uiSchema?: UiSchema<T, F>;
+    uiSchema?: UiSchema<T, S, F>;
     /** An object containing the id for this object & ids for its properties */
     idSchema: IdSchema<T>;
     /** The form data for the object */
-    formData: T;
+    formData?: T;
     /** The `formContext` object that was passed to Form */
     formContext?: F;
     /** The `registry` object */
-    registry: Registry<T, F>;
+    registry: Registry<T, S, F>;
 };
+/** The properties that are passed to a WrapIfAdditionalTemplate implementation */
+type WrapIfAdditionalTemplateProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = {
+    /** The field or widget component instance for this field row */
+    children: React.ReactNode;
+} & Pick<FieldTemplateProps<T, S, F>, "id" | "classNames" | "style" | "label" | "required" | "readonly" | "disabled" | "schema" | "uiSchema" | "onKeyChange" | "onDropPropertyClick" | "registry">;
 /** 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">> {
+interface WidgetProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = 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;
+    schema: S;
     /** The uiSchema for this widget */
-    uiSchema?: UiSchema<T, F>;
+    uiSchema?: UiSchema<T, S, F>;
     /** The current value for this widget */
     value: any;
     /** The required status of this widget */
@@ -503,9 +530,9 @@ interface WidgetProps<T = any, F = any> extends GenericObjectType, Pick<React.HT
     /** 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>> & {
+    options: NonNullable<UIOptionsType<T, S, F>> & {
         /** The enum options list for a type that supports them */
-        enumOptions?: EnumOptionsType[];
+        enumOptions?: EnumOptionsType<S>[];
     };
     /** The `formContext` object that you passed to `Form` */
     formContext?: F;
@@ -522,24 +549,30 @@ interface WidgetProps<T = any, F = any> extends GenericObjectType, Pick<React.HT
     /** An array of strings listing all generated error messages from encountered errors for this widget */
     rawErrors?: string[];
     /** The `registry` object */
-    registry: Registry<T, F>;
+    registry: Registry<T, S, F>;
 }
 /** The definition of a React-based Widget component */
-declare type Widget<T = any, F = any> = React.ComponentType<WidgetProps<T, F>>;
+type Widget<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = React.ComponentType<WidgetProps<T, S, F>>;
 /** The type that defines the props used by the Submit button */
-declare type SubmitButtonProps<T = any, F = any> = {
+type SubmitButtonProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = {
     /** The uiSchema for this widget */
-    uiSchema?: UiSchema<T, F>;
+    uiSchema?: UiSchema<T, S, F>;
+    /** The `registry` object */
+    registry: Registry<T, S, F>;
 };
 /** The type that defines the props for an Icon button, extending from a basic HTML button attributes */
-declare type IconButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement> & {
+type IconButtonProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = 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 uiSchema for this widget */
+    uiSchema?: UiSchema<T, S, F>;
+    /** The `registry` object */
+    registry: Registry<T, S, F>;
 };
 /** The type that defines how to change the behavior of the submit button for the form */
-declare type UISchemaSubmitButtonOptions = {
+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 */
@@ -553,24 +586,26 @@ declare type UISchemaSubmitButtonOptions = {
     };
 };
 /** This type represents an element used to render an enum option */
-declare type EnumOptionsType = {
+type EnumOptionsType<S extends StrictRJSFSchema = RJSFSchema> = {
     /** 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;
+    schema?: S;
 };
 /** 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> = {
+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">> & {
+type UIOptionsBaseType<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = Partial<Omit<TemplatesType<T, S, F>, "ButtonTemplates">> & {
     /** Any classnames that the user wants to be applied to a field in the ui */
     classNames?: string;
+    /** Any custom style that the user wants to apply to a field in the ui, applied on the same element as classNames */
+    style?: StyleHTMLAttributes<any>;
     /** 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 */
@@ -616,40 +651,48 @@ declare type UIOptionsBaseType<T = any, F = any> = Partial<Omit<TemplatesType<T,
     /** 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;
+    widget?: Widget<T, S, 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> & {
+type UIOptionsType<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = UIOptionsBaseType<T, S, 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>> & {
+type UiSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = GenericObjectType & MakeUIType<UIOptionsBaseType<T, S, 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>;
+    "ui:field"?: Field<T, S, F> | string;
+    /** By default, any field that is rendered for an `anyOf`/`oneOf` schema will be wrapped inside the `AnyOfField` or
+     * `OneOfField` component. This default behavior may be undesirable if your custom field already handles behavior
+     * related to choosing one or more subschemas contained in the `anyOf`/`oneOf` schema.
+     * By providing a `true` value for this flag in association with a custom `ui:field`, the wrapped components will be
+     * omitted, so just one instance of the custom field will be rendered. If the flag is omitted or set to `false`,
+     * your custom field will be wrapped by `AnyOfField`/`OneOfField`.
+     */
+    "ui:fieldReplacesAnyOrOneOf"?: boolean;
+    /** An object that contains all the potential UI options in a single object */
+    "ui:options"?: UIOptionsType<T, S, 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`
+/** A `CustomValidator` function takes in a `formData`, `errors` and `uiSchema` objects 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
+type CustomValidator<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = (formData: T | undefined, errors: FormValidation<T>, uiSchema?: UiSchema<T, S, F>) => FormValidation<T>;
+/** An `ErrorTransformer` function will take in a list of `errors` & a `uiSchema` and potentially return a
+ * transformation of those errors in what ever way it deems necessary
  */
-declare type ErrorTransformer = (errors: RJSFValidationError[]) => RJSFValidationError[];
+type ErrorTransformer<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> = (errors: RJSFValidationError[], uiSchema?: UiSchema<T, S, F>) => RJSFValidationError[];
 /** The type that describes the data that is returned from the `ValidatorType.validateFormData()` function */
-declare type ValidationData<T> = {
+type ValidationData<T> = {
     /** The validation errors as a list of `RJSFValidationError` objects */
     errors: RJSFValidationError[];
     /** The validation errors in the form of an `ErrorSchema` */
@@ -658,7 +701,7 @@ declare type ValidationData<T> = {
 /** The interface that describes the validation functions that are provided by a Validator implementation used by the
  * schema utilities.
  */
-interface ValidatorType<T = any> {
+interface ValidatorType<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = 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
@@ -668,8 +711,9 @@ interface ValidatorType<T = any> {
      * @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
+     * @param [uiSchema] - An optional uiSchema that is passed to `transformErrors` and `customValidate`
      */
-    validateFormData(formData: T, schema: RJSFSchema, customValidate?: CustomValidator<T>, transformErrors?: ErrorTransformer): ValidationData<T>;
+    validateFormData(formData: T | undefined, schema: S, customValidate?: CustomValidator<T, S, F>, transformErrors?: ErrorTransformer<T, S, F>, uiSchema?: UiSchema<T, S, F>): ValidationData<T>;
     /** Converts an `errorSchema` into a list of `RJSFValidationErrors`
      *
      * @param errorSchema - The `ErrorSchema` instance to convert
@@ -681,22 +725,32 @@ interface ValidatorType<T = any> {
      * false.
      *
      * @param schema - The schema against which to validate the form data   * @param schema
-     * @param formData- - The form data to validate
+     * @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;
+    isValid(schema: S, formData: T | undefined, rootSchema: S): boolean;
+    /** Runs the pure validation of the `schema` and `formData` without any of the RJSF functionality. Provided for use
+     * by the playground. Returns the `errors` from the validation
+     *
+     * @param schema - The schema against which to validate the form data   * @param schema
+     * @param formData - The form data to validate
+     */
+    rawValidation<Result = any>(schema: S, formData?: T): {
+        errors?: Result[];
+        validationError?: Error;
+    };
 }
 /** 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> {
+interface SchemaUtilsType<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> {
     /** Returns the `ValidatorType` in the `SchemaUtilsType`
      *
      * @returns - The `ValidatorType`
      */
-    getValidator(): ValidatorType<T>;
+    getValidator(): ValidatorType<T, S, F>;
     /** 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.
@@ -705,16 +759,18 @@ interface SchemaUtilsType<T = any> {
      * @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;
+    doesSchemaUtilsDiffer(validator: ValidatorType<T, S, F>, rootSchema: S): 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
+     * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults.
+     *          If "excludeObjectChildren", pass `includeUndefinedValues` as false when computing defaults for any nested
+     *          object properties.
      * @returns - The resulting `formData` with all the defaults provided
      */
-    getDefaultFormState(schema: RJSFSchema, formData?: T, includeUndefinedValues?: boolean): T | T[] | undefined;
+    getDefaultFormState(schema: S, formData?: T, includeUndefinedValues?: boolean | "excludeObjectChildren"): 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.
      *
@@ -722,39 +778,60 @@ interface SchemaUtilsType<T = any> {
      * @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;
+    getDisplayLabel(schema: S, uiSchema?: UiSchema<T, S, F>): boolean;
+    /** Determines which of the given `options` provided most closely matches the `formData`.
+     * Returns the index of the option that is valid and is the closest match, or 0 if there is no match.
+     *
+     * The closest match is determined using the number of matching properties, and more heavily favors options with
+     * matching readOnly, default, or const values.
+     *
+     * @param formData - The form data associated with the schema
+     * @param options - The list of options that can be selected from
+     * @param [selectedOption] - The index of the currently selected option, defaulted to -1 if not specified
+     * @returns - The index of the option that is the closest match to the `formData` or the `selectedOption` if no match
+     */
+    getClosestMatchingOption(formData: T | undefined, options: S[], selectedOption?: number): number;
+    /** Given the `formData` and list of `options`, attempts to find the index of the first option that matches the data.
+     * Always returns the first option if there is nothing that matches.
+     *
+     * @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
+     * @returns - The firstindex of the matched option or 0 if none is available
+     */
+    getFirstMatchingOption(formData: T | undefined, options: S[]): number;
     /** Given the `formData` and list of `options`, attempts to find the index of the option that best matches the data.
+     * Deprecated, use `getFirstMatchingOption()` instead.
      *
      * @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
+     * @deprecated
      */
-    getMatchingOption(formData: T, options: RJSFSchema[]): number;
+    getMatchingOption(formData: T | undefined, options: S[]): 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;
+    isFilesArray(schema: S, uiSchema?: UiSchema<T, S, 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;
+    isMultiSelect(schema: S): 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;
+    isSelect(schema: S): 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.
@@ -765,10 +842,22 @@ interface SchemaUtilsType<T = any> {
      * 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
+     * @param [formData] - 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;
+    retrieveSchema(schema: S, formData?: T): S;
+    /** Sanitize the `data` associated with the `oldSchema` so it is considered appropriate for the `newSchema`. If the
+     * new schema does not contain any properties, then `undefined` is returned to clear all the form data. Due to the
+     * nature of schemas, this sanitization happens recursively for nested objects of data. Also, any properties in the
+     * old schema that are non-existent in the new schema are set to `undefined`.
+     *
+     * @param [newSchema] - The new schema for which the data is being sanitized
+     * @param [oldSchema] - The old schema from which the data originated
+     * @param [data={}] - The form data associated with the schema, defaulting to an empty object when undefined
+     * @returns - The new form data, with all of the fields uniquely associated with the old schema set
+     *      to `undefined`. Will return `undefined` if the new schema is not an object containing properties.
+     */
+    sanitizeDataForNewSchema(newSchema?: S, oldSchema?: S, data?: any): T;
     /** Generates an `IdSchema` object for the `schema`, recursively
      *
      * @param schema - The schema for which the display label flag is desired
@@ -778,7 +867,7 @@ interface SchemaUtilsType<T = any> {
      * @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>;
+    toIdSchema(schema: S, 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
@@ -786,7 +875,7 @@ interface SchemaUtilsType<T = any> {
      * @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>;
+    toPathSchema(schema: S, name?: string, formData?: T): PathSchema<T>;
 }
 
 /** Checks the schema to see if it is allowing additional items, by verifying that `schema.additionalItems` is an
@@ -795,7 +884,7 @@ interface SchemaUtilsType<T = any> {
  * @param schema - The schema object to check
  * @returns - True if additional items is allowed, otherwise false
  */
-declare function allowAdditionalItems(schema: RJSFSchema): boolean;
+declare function allowAdditionalItems<S extends StrictRJSFSchema = RJSFSchema>(schema: S): 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
@@ -817,7 +906,7 @@ declare function asNumber(value: string | null): string | number | null | undefi
  * @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;
+declare function canExpand<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(schema: RJSFSchema, uiSchema?: UiSchema<T, S, 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.
@@ -826,7 +915,7 @@ declare function canExpand<T = any, F = any>(schema: RJSFSchema, uiSchema?: UiSc
  * @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>;
+declare function createSchemaUtils<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, rootSchema: S): SchemaUtilsType<T, S, F>;
 
 /** 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`.
@@ -848,6 +937,124 @@ declare function dataURItoBlob(dataURI: string): {
  */
 declare function deepEquals(a: any, b: any): boolean;
 
+/** Removes the enum option value at the `valueIndex` from the currently `selected` (list of) value(s). If `selected` is
+ * a list, then that list is updated to remove the enum option value with the `valueIndex` in `allEnumOptions`. If it is
+ * a single value, then if the enum option value with the `valueIndex` in `allEnumOptions` matches `selected`, undefined
+ * is returned, otherwise the `selected` value is returned.
+ *
+ * @param valueIndex - The index of the value to be removed from the selected list or single value
+ * @param selected - The current (list of) selected value(s)
+ * @param [allEnumOptions=[]] - The list of all the known enumOptions
+ * @returns - The updated `selected` with the enum option value at `valueIndex` in `allEnumOptions` removed from it,
+ *        unless `selected` is a single value. In that case, if the `valueIndex` value matches `selected`, returns
+ *        undefined, otherwise `selected`.
+ */
+declare function enumOptionsDeselectValue<S extends StrictRJSFSchema = RJSFSchema>(valueIndex: string | number, selected?: EnumOptionsType<S>["value"] | EnumOptionsType<S>["value"][], allEnumOptions?: EnumOptionsType<S>[]): EnumOptionsType<S>["value"] | EnumOptionsType<S>["value"][] | undefined;
+
+/** Returns the index(es) of the options in `allEnumOptions` whose value(s) match the ones in `value`. All the
+ * `enumOptions` are filtered based on whether they are a "selected" `value` and the index of each selected one is then
+ * stored in an array. If `multiple` is true, that array is returned, otherwise the first element in the array is
+ * returned.
+ *
+ * @param value - The single value or list of values for which indexes are desired
+ * @param [allEnumOptions=[]] - The list of all the known enumOptions
+ * @param [multiple=false] - Optional flag, if true will return a list of index, otherwise a single one
+ * @returns - A single string index for the first `value` in `allEnumOptions`, if not `multiple`. Otherwise, the list
+ *        of indexes for (each of) the value(s) in `value`.
+ */
+declare function enumOptionsIndexForValue<S extends StrictRJSFSchema = RJSFSchema>(value: EnumOptionsType<S>["value"] | EnumOptionsType<S>["value"][], allEnumOptions?: EnumOptionsType<S>[], multiple?: boolean): string | string[] | undefined;
+
+/** Determines whether the given `value` is (one of) the `selected` value(s).
+ *
+ * @param value - The value being checked to see if it is selected
+ * @param selected - The current selected value or list of values
+ * @returns - true if the `value` is one of the `selected` ones, false otherwise
+ */
+declare function enumOptionsIsSelected<S extends StrictRJSFSchema = RJSFSchema>(value: EnumOptionsType<S>["value"], selected: EnumOptionsType<S>["value"] | EnumOptionsType<S>["value"][]): boolean;
+
+/** Add the enum option value at the `valueIndex` to the list of `selected` values in the proper order as defined by
+ * `allEnumOptions`
+ *
+ * @param valueIndex - The index of the value that should be selected
+ * @param selected - The current list of selected values
+ * @param [allEnumOptions=[]] - The list of all the known enumOptions
+ * @returns - The updated list of selected enum values with enum value at the `valueIndex` added to it
+ */
+declare function enumOptionsSelectValue<S extends StrictRJSFSchema = RJSFSchema>(valueIndex: string | number, selected: EnumOptionsType<S>["value"][], allEnumOptions?: EnumOptionsType<S>[]): any[];
+
+/** Returns the value(s) from `allEnumOptions` at the index(es) provided by `valueIndex`. If `valueIndex` is not an
+ * array AND the index is not valid for `allEnumOptions`, `emptyValue` is returned. If `valueIndex` is an array, AND it
+ * contains an invalid index, the returned array will have the resulting undefined values filtered out, leaving only
+ * valid values or in the worst case, an empty array.
+ *
+ * @param valueIndex - The index(es) of the value(s) that should be returned
+ * @param [allEnumOptions=[]] - The list of all the known enumOptions
+ * @param [emptyValue] - The value to return when the non-array `valueIndex` does not refer to a real option
+ * @returns - The single or list of values specified by the single or list of indexes if they are valid. Otherwise,
+ *        `emptyValue` or an empty list.
+ */
+declare function enumOptionsValueForIndex<S extends StrictRJSFSchema = RJSFSchema>(valueIndex: string | number | Array<string | number>, allEnumOptions?: EnumOptionsType<S>[], emptyValue?: EnumOptionsType<S>["value"]): EnumOptionsType<S>["value"] | EnumOptionsType<S>["value"][] | undefined;
+
+/** The `ErrorSchemaBuilder<T>` is used to build an `ErrorSchema<T>` since the definition of the `ErrorSchema` type is
+ * designed for reading information rather than writing it. Use this class to add, replace or clear errors in an error
+ * schema by using either dotted path or an array of path names. Once you are done building the `ErrorSchema`, you can
+ * get the result and/or reset all the errors back to an initial set and start again.
+ */
+declare class ErrorSchemaBuilder<T = any> {
+    /** The error schema being built
+     *
+     * @private
+     */
+    private errorSchema;
+    /** Construct an `ErrorSchemaBuilder` with an optional initial set of errors in an `ErrorSchema`.
+     *
+     * @param [initialSchema] - The optional set of initial errors, that will be cloned into the class
+     */
+    constructor(initialSchema?: ErrorSchema<T>);
+    /** Returns the `ErrorSchema` that has been updated by the methods of the `ErrorSchemaBuilder`
+     */
+    get ErrorSchema(): ErrorSchema<T>;
+    /** Will get an existing `ErrorSchema` at the specified `pathOfError` or create and return one.
+     *
+     * @param [pathOfError] - The optional path into the `ErrorSchema` at which to add the error(s)
+     * @returns - The error block for the given `pathOfError` or the root if not provided
+     * @private
+     */
+    private getOrCreateErrorBlock;
+    /** Resets all errors in the `ErrorSchemaBuilder` back to the `initialSchema` if provided, otherwise an empty set.
+     *
+     * @param [initialSchema] - The optional set of initial errors, that will be cloned into the class
+     * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+     */
+    resetAllErrors(initialSchema?: ErrorSchema<T>): this;
+    /** Adds the `errorOrList` to the list of errors in the `ErrorSchema` at either the root level or the location within
+     * the schema described by the `pathOfError`. For more information about how to specify the path see the
+     * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
+     *
+     * @param errorOrList - The error or list of errors to add into the `ErrorSchema`
+     * @param [pathOfError] - The optional path into the `ErrorSchema` at which to add the error(s)
+     * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+     */
+    addErrors(errorOrList: string | string[], pathOfError?: string | string[]): this;
+    /** Sets/replaces the `errorOrList` as the error(s) in the `ErrorSchema` at either the root level or the location
+     * within the schema described by the `pathOfError`. For more information about how to specify the path see the
+     * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
+     *
+     * @param errorOrList - The error or list of errors to set into the `ErrorSchema`
+     * @param [pathOfError] - The optional path into the `ErrorSchema` at which to set the error(s)
+     * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+     */
+    setErrors(errorOrList: string | string[], pathOfError?: string | string[]): this;
+    /** Clears the error(s) in the `ErrorSchema` at either the root level or the location within the schema described by
+     * the `pathOfError`. For more information about how to specify the path see the
+     * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
+     *
+     * @param [pathOfError] - The optional path into the `ErrorSchema` at which to clear the error(s)
+     * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+     */
+    clearErrors(pathOfError?: string | string[]): this;
+}
+
 /** 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.
@@ -857,7 +1064,7 @@ declare function deepEquals(a: any, b: any): boolean;
  * @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;
+declare function findSchemaDefinition<S extends StrictRJSFSchema = RJSFSchema>($ref?: string, rootSchema?: S): S;
 
 /** Using the `schema`, `defaultType` and `options`, extract out the props for the <input> element that make sense.
  *
@@ -867,7 +1074,7 @@ declare function findSchemaDefinition($ref?: string, rootSchema?: RJSFSchema): R
  * @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;
+declare function getInputProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(schema: RJSFSchema, defaultType?: string, options?: UIOptionsType<T, S, 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:
@@ -880,14 +1087,14 @@ declare function getInputProps<T = any, F = any>(schema: RJSFSchema, defaultType
  * @param schema - The schema for which to get the type
  * @returns - The type of the schema
  */
-declare function getSchemaType(schema: RJSFSchema): string | string[] | undefined;
+declare function getSchemaType<S extends StrictRJSFSchema = RJSFSchema>(schema: S): 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;
+declare function getSubmitButtonOptions<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(uiSchema?: UiSchema<T, S, 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.
@@ -897,15 +1104,15 @@ declare function getSubmitButtonOptions<T = any, F = any>(uiSchema?: UiSchema<T,
  * @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];
+declare function getTemplate<Name extends keyof TemplatesType<T, S, F>, T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(name: Name, registry: Registry<T, S, F>, uiOptions?: UIOptionsType<T, S, F>): TemplatesType<T, S, 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
+ * @returns - An object containing all the `ui:xxx` options with the stripped off
  */
-declare function getUiOptions<T = any, F = any>(uiSchema?: UiSchema<T, F>): UIOptionsType<T, F>;
+declare function getUiOptions<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(uiSchema?: UiSchema<T, S, F>): UIOptionsType<T, S, 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
@@ -918,7 +1125,7 @@ declare function getUiOptions<T = any, F = any>(uiSchema?: UiSchema<T, F>): UIOp
  * @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>;
+declare function getWidget<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(schema: RJSFSchema, widget?: Widget<T, S, F> | string, registeredWidgets?: RegistryWidgetsType<T, S, F>): Widget<T, S, 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.
@@ -936,7 +1143,54 @@ declare function guessType(value: any): "array" | "string" | "null" | "boolean"
  * @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;
+declare function hasWidget<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(schema: RJSFSchema, widget: Widget<T, S, F> | string, registeredWidgets?: RegistryWidgetsType<T, S, F>): boolean;
+
+/** Return a consistent `id` for the field description element
+ *
+ * @param id - Either simple string id or an IdSchema from which to extract it
+ * @returns - The consistent id for the field description element from the given `id`
+ */
+declare function descriptionId<T = any>(id: IdSchema<T> | string): string;
+/** Return a consistent `id` for the field error element
+ *
+ * @param id - Either simple string id or an IdSchema from which to extract it
+ * @returns - The consistent id for the field error element from the given `id`
+ */
+declare function errorId<T = any>(id: IdSchema<T> | string): string;
+/** Return a consistent `id` for the field examples element
+ *
+ * @param id - Either simple string id or an IdSchema from which to extract it
+ * @returns - The consistent id for the field examples element from the given `id`
+ */
+declare function examplesId<T = any>(id: IdSchema<T> | string): string;
+/** Return a consistent `id` for the field help element
+ *
+ * @param id - Either simple string id or an IdSchema from which to extract it
+ * @returns - The consistent id for the field help element from the given `id`
+ */
+declare function helpId<T = any>(id: IdSchema<T> | string): string;
+/** Return a consistent `id` for the field title element
+ *
+ * @param id - Either simple string id or an IdSchema from which to extract it
+ * @returns - The consistent id for the field title element from the given `id`
+ */
+declare function titleId<T = any>(id: IdSchema<T> | string): string;
+/** Return a list of element ids that contain additional information about the field that can be used to as the aria
+ * description of the field. This is correctly omitting `titleId` which would be "labeling" rather than "describing" the
+ * element.
+ *
+ * @param id - Either simple string id or an IdSchema from which to extract it
+ * @param [includeExamples=false] - Optional flag, if true, will add the `examplesId` into the list
+ * @returns - The string containing the list of ids for use in an `aria-describedBy` attribute
+ */
+declare function ariaDescribedByIds<T = any>(id: IdSchema<T> | string, includeExamples?: boolean): string;
+/** Return a consistent `id` for the `optionIndex`s of a `Radio` or `Checkboxes` widget
+ *
+ * @param id - The id of the parent component for the option
+ * @param optionIndex - The index of the option for which the id is desired
+ * @returns - An id for the option index based on the parent `id`
+ */
+declare function optionId(id: string, optionIndex: number): string;
 
 /** 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.
@@ -944,14 +1198,14 @@ declare function hasWidget<T = any, F = any>(schema: RJSFSchema, widget: Widget<
  * @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;
+declare function isConstant<S extends StrictRJSFSchema = RJSFSchema>(schema: S): 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;
+declare function isCustomWidget<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(uiSchema?: UiSchema<T, S, 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.
@@ -959,7 +1213,7 @@ declare function isCustomWidget<T = any, F = any>(uiSchema?: UiSchema<T, F>): bo
  * @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;
+declare function isFixedItems<S extends StrictRJSFSchema = RJSFSchema>(schema: S): 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.
@@ -986,20 +1240,22 @@ declare function localToUTC(dateString: string): string | undefined;
  *   - 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
+ * @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;
+declare function mergeDefaultsWithFormData<T = any>(defaults?: T, formData?: T): T | undefined;
 
 /** 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
+ * @param [concatArrays=false] - Optional flag that, when true, will cause arrays to be concatenated. Use
+ *          "preventDuplicates" to merge arrays in a manner that prevents any duplicate entries from being merged.
+ *          NOTE: Uses shallow comparison for the duplicate checking.
  * @returns - A new object that is the merge of the two given objects
  */
-declare function mergeObjects(obj1: GenericObjectType, obj2: GenericObjectType, concatArrays?: boolean): GenericObjectType;
+declare function mergeObjects(obj1: GenericObjectType, obj2: GenericObjectType, concatArrays?: boolean | "preventDuplicates"): 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
@@ -1019,7 +1275,7 @@ declare function mergeSchemas(obj1: GenericObjectType, obj2: GenericObjectType):
  * @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;
+declare function optionsList<S extends StrictRJSFSchema = RJSFSchema>(schema: S): EnumOptionsType<S>[] | 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
@@ -1050,24 +1306,13 @@ declare function pad(num: number, width: number): 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;
+declare function rangeSpec<S extends StrictRJSFSchema = RJSFSchema>(schema: S): RangeSpecType;
 
 /** Check to see if a `schema` specifies that a value must be true. This happens when:
  * - `schema.const` is truthy
@@ -1078,7 +1323,7 @@ declare function rangeSpec(schema: RJSFSchema): RangeSpecType;
  * @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;
+declare function schemaRequiresTrueValue<S extends StrictRJSFSchema = RJSFSchema>(schema: S): 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.
@@ -1097,7 +1342,7 @@ declare function shouldRender(component: React.Component, nextProps: any, nextSt
  * @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;
+declare function toConstant<S extends StrictRJSFSchema = RJSFSchema>(schema: S): 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.
@@ -1150,10 +1395,12 @@ declare const UI_OPTIONS_KEY = "ui:options";
  * @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
+ * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults.
+ *          If "excludeObjectChildren", pass `includeUndefinedValues` as false when computing defaults for any nested
+ *          object properties.
  * @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;
+declare function getDefaultFormState<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, theSchema: S, formData?: T, rootSchema?: S, includeUndefinedValues?: boolean | "excludeObjectChildren"): 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.
@@ -1164,17 +1411,52 @@ declare function getDefaultFormState<T = any>(validator: ValidatorType, theSchem
  * @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;
+declare function getDisplayLabel<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, uiSchema?: UiSchema<T, S, F>, rootSchema?: S): boolean;
+
+/** Determines which of the given `options` provided most closely matches the `formData`. Using
+ * `getFirstMatchingOption()` to match two schemas that differ only by the readOnly, default or const value of a field
+ * based on the `formData` and returns 0 when there is no match. Rather than passing in all the `options` at once to
+ * this utility, instead an array of valid option indexes is created by iterating over the list of options, call
+ * `getFirstMatchingOptions` with a list of one junk option and one good option, seeing if the good option is considered
+ * matched.
+ *
+ * Once the list of valid indexes is created, if there is only one valid index, just return it. Otherwise, if there are
+ * no valid indexes, then fill the valid indexes array with the indexes of all the options. Next, the index of the
+ * option with the highest score is determined by iterating over the list of valid options, calling
+ * `calculateIndexScore()` on each, comparing it against the current best score, and returning the index of the one that
+ * eventually has the best score.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param rootSchema - The root JSON schema of the entire form
+ * @param formData - The form data associated with the schema
+ * @param options - The list of options that can be selected from
+ * @param [selectedOption=-1] - The index of the currently selected option, defaulted to -1 if not specified
+ * @returns - The index of the option that is the closest match to the `formData` or the `selectedOption` if no match
+ */
+declare function getClosestMatchingOption<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, rootSchema: S, formData: T | undefined, options: S[], selectedOption?: number): number;
+
+/** Given the `formData` and list of `options`, attempts to find the index of the first option that matches the data.
+ * Always returns the first option if there is nothing that matches.
+ *
+ * @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 first matched option or 0 if none is available
+ */
+declare function getFirstMatchingOption<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, formData: T | undefined, options: S[], rootSchema: S): number;
 
 /** Given the `formData` and list of `options`, attempts to find the index of the option that best matches the data.
+ * Deprecated, use `getFirstMatchingOption()` instead.
  *
  * @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
+ * @deprecated
  */
-declare function getMatchingOption<T = any>(validator: ValidatorType, formData: T | undefined, options: RJSFSchema[], rootSchema: RJSFSchema): number;
+declare function getMatchingOption<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, formData: T | undefined, options: S[], rootSchema: S): number;
 
 /** Checks to see if the `schema` and `uiSchema` combination represents an array of files
  *
@@ -1184,7 +1466,7 @@ declare function getMatchingOption<T = any>(validator: ValidatorType, formData:
  * @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;
+declare function isFilesArray<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, uiSchema?: UiSchema<T, S, F>, rootSchema?: S): boolean;
 
 /** Checks to see if the `schema` combination represents a multi-select
  *
@@ -1193,7 +1475,7 @@ declare function isFilesArray<T = any, F = any>(validator: ValidatorType, schema
  * @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;
+declare function isMultiSelect<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema?: S): boolean;
 
 /** Checks to see if the `schema` combination represents a select
  *
@@ -1202,7 +1484,7 @@ declare function isMultiSelect<T = any>(validator: ValidatorType, schema: RJSFSc
  * @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;
+declare function isSelect<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, theSchema: S, rootSchema?: S): 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
@@ -1214,19 +1496,68 @@ declare function isSelect<T = any>(validator: ValidatorType, theSchema: RJSFSche
  * @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>;
+declare function mergeValidationData<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, 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 validator - An implementation of the `ValidatorType<T, S>` 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;
+declare function retrieveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema?: S, rawFormData?: T): S;
+
+/** Sanitize the `data` associated with the `oldSchema` so it is considered appropriate for the `newSchema`. If the new
+ * schema does not contain any properties, then `undefined` is returned to clear all the form data. Due to the nature
+ * of schemas, this sanitization happens recursively for nested objects of data. Also, any properties in the old schema
+ * that are non-existent in the new schema are set to `undefined`. The data sanitization process has the following flow:
+ *
+ * - If the new schema is an object that contains a `properties` object then:
+ *   - Create a `removeOldSchemaData` object, setting each key in the `oldSchema.properties` having `data` to undefined
+ *   - Create an empty `nestedData` object for use in the key filtering below:
+ *   - Iterate over each key in the `newSchema.properties` as follows:
+ *     - Get the `formValue` of the key from the `data`
+ *     - Get the `oldKeySchema` and `newKeyedSchema` for the key, defaulting to `{}` when it doesn't exist
+ *     - Retrieve the schema for any refs within each `oldKeySchema` and/or `newKeySchema`
+ *     - Get the types of the old and new keyed schemas and if the old doesn't exist or the old & new are the same then:
+ *       - If `removeOldSchemaData` has an entry for the key, delete it since the new schema has the same property
+ *       - If type of the key in the new schema is `object`:
+ *         - Store the value from the recursive `sanitizeDataForNewSchema` call in `nestedData[key]`
+ *       - Otherwise, check for default or const values:
+ *         - Get the old and new `default` values from the schema and check:
+ *           - If the new `default` value does not match the form value:
+ *             - If the old `default` value DOES match the form value, then:
+ *               - Replace `removeOldSchemaData[key]` with the new `default`
+ *               - Otherwise, if the new schema is `readOnly` then replace `removeOldSchemaData[key]` with undefined
+ *         - Get the old and new `const` values from the schema and check:
+ *           - If the new `const` value does not match the form value:
+ *           - If the old `const` value DOES match the form value, then:
+ *             - Replace `removeOldSchemaData[key]` with the new `const`
+ *             - Otherwise, replace `removeOldSchemaData[key]` with undefined
+ *   - Once all keys have been processed, return an object built as follows:
+ *     - `{ ...removeOldSchemaData, ...nestedData, ...pick(data, keysToKeep) }`
+ * - If the new and old schema types are array and the `data` is an array then:
+ *   - If the type of the old and new schema `items` are a non-array objects:
+ *     - Retrieve the schema for any refs within each `oldKeySchema.items` and/or `newKeySchema.items`
+ *     - If the `type`s of both items are the same (or the old does not have a type):
+ *       - If the type is "object", then:
+ *         - For each element in the `data` recursively sanitize the data, stopping at `maxItems` if specified
+ *       - Otherwise, just return the `data` removing any values after `maxItems` if it is set
+ *   - If the type of the old and new schema `items` are booleans of the same value, return `data` as is
+ * - Otherwise return `undefined`
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param rootSchema - The root JSON schema of the entire form
+ * @param [newSchema] - The new schema for which the data is being sanitized
+ * @param [oldSchema] - The old schema from which the data originated
+ * @param [data={}] - The form data associated with the schema, defaulting to an empty object when undefined
+ * @returns - The new form data, with all the fields uniquely associated with the old schema set
+ *      to `undefined`. Will return `undefined` if the new schema is not an object containing properties.
+ */
+declare function sanitizeDataForNewSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, rootSchema: S, newSchema?: S, oldSchema?: S, data?: any): T;
 
 /** Generates an `IdSchema` object for the `schema`, recursively
  *
@@ -1239,7 +1570,7 @@ declare function retrieveSchema<T = any>(validator: ValidatorType, schema: RJSFS
  * @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>;
+declare function toIdSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, id?: string | null, rootSchema?: S, formData?: T, idPrefix?: string, idSeparator?: string): IdSchema<T>;
 
 /** Generates an `PathSchema` object for the `schema`, recursively
  *
@@ -1250,6 +1581,6 @@ declare function toIdSchema<T = any>(validator: ValidatorType, schema: RJSFSchem
  * @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>;
+declare function toPathSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, name?: string, rootSchema?: S, 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, FieldErrorProps, FieldErrors, FieldHelpProps, 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 };
+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, ErrorSchemaBuilder, ErrorTransformer, Field, FieldError, FieldErrorProps, FieldErrors, FieldHelpProps, FieldId, FieldPath, FieldProps, FieldTemplateProps, FieldValidation, FormContextType, FormValidation, GenericObjectType, ID_KEY, ITEMS_KEY, IconButtonProps, IdSchema, InputPropsType, NAME_KEY, ONE_OF_KEY, ObjectFieldTemplatePropertyType, ObjectFieldTemplateProps, PROPERTIES_KEY, PathSchema, REF_KEY, REQUIRED_KEY, RJSFSchema, RJSFValidationError, RJSF_ADDITONAL_PROPERTIES_FLAG, RangeSpecType, Registry, RegistryFieldsType, RegistryWidgetsType, SUBMIT_BTN_OPTIONS_KEY, SchemaUtilsType, StrictRJSFSchema, SubmitButtonProps, TemplatesType, TitleFieldProps, UIOptionsType, UISchemaSubmitButtonOptions, UI_FIELD_KEY, UI_OPTIONS_KEY, UI_WIDGET_KEY, UiSchema, UnsupportedFieldProps, ValidationData, ValidatorType, Widget, WidgetProps, WrapIfAdditionalTemplateProps, allowAdditionalItems, ariaDescribedByIds, asNumber, canExpand, createSchemaUtils, dataURItoBlob, deepEquals, descriptionId, enumOptionsDeselectValue, enumOptionsIndexForValue, enumOptionsIsSelected, enumOptionsSelectValue, enumOptionsValueForIndex, errorId, examplesId, findSchemaDefinition, getClosestMatchingOption, getDefaultFormState, getDisplayLabel, getFirstMatchingOption, getInputProps, getMatchingOption, getSchemaType, getSubmitButtonOptions, getTemplate, getUiOptions, getWidget, guessType, hasWidget, helpId, isConstant, isCustomWidget, isFilesArray, isFixedItems, isMultiSelect, isObject, isSelect, localToUTC, mergeDefaultsWithFormData, mergeObjects, mergeSchemas, mergeValidationData, optionId, optionsList, orderProperties, pad, parseDateString, rangeSpec, retrieveSchema, sanitizeDataForNewSchema, schemaRequiresTrueValue, shouldRender, titleId, toConstant, toDateString, toIdSchema, toPathSchema, utcToLocal };