@rjsf/utils 5.11.2 → 5.12.0

package/lib/schema/index.d.ts

@@ -0,0 +1,14 @@
+import getDefaultFormState from './getDefaultFormState';
+import getDisplayLabel from './getDisplayLabel';
+import getClosestMatchingOption from './getClosestMatchingOption';
+import getFirstMatchingOption from './getFirstMatchingOption';
+import getMatchingOption from './getMatchingOption';
+import isFilesArray from './isFilesArray';
+import isMultiSelect from './isMultiSelect';
+import isSelect from './isSelect';
+import mergeValidationData from './mergeValidationData';
+import retrieveSchema from './retrieveSchema';
+import sanitizeDataForNewSchema from './sanitizeDataForNewSchema';
+import toIdSchema from './toIdSchema';
+import toPathSchema from './toPathSchema';
+export { getDefaultFormState, getDisplayLabel, getClosestMatchingOption, getFirstMatchingOption, getMatchingOption, isFilesArray, isMultiSelect, isSelect, mergeValidationData, retrieveSchema, sanitizeDataForNewSchema, toIdSchema, toPathSchema, };

package/lib/schema/index.js

@@ -0,0 +1,15 @@
+import getDefaultFormState from './getDefaultFormState';
+import getDisplayLabel from './getDisplayLabel';
+import getClosestMatchingOption from './getClosestMatchingOption';
+import getFirstMatchingOption from './getFirstMatchingOption';
+import getMatchingOption from './getMatchingOption';
+import isFilesArray from './isFilesArray';
+import isMultiSelect from './isMultiSelect';
+import isSelect from './isSelect';
+import mergeValidationData from './mergeValidationData';
+import retrieveSchema from './retrieveSchema';
+import sanitizeDataForNewSchema from './sanitizeDataForNewSchema';
+import toIdSchema from './toIdSchema';
+import toPathSchema from './toPathSchema';
+export { getDefaultFormState, getDisplayLabel, getClosestMatchingOption, getFirstMatchingOption, getMatchingOption, isFilesArray, isMultiSelect, isSelect, mergeValidationData, retrieveSchema, sanitizeDataForNewSchema, toIdSchema, toPathSchema, };
+//# sourceMappingURL=index.js.map

package/lib/schema/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,mBAAmB,MAAM,uBAAuB,CAAC;AACxD,OAAO,eAAe,MAAM,mBAAmB,CAAC;AAChD,OAAO,wBAAwB,MAAM,4BAA4B,CAAC;AAClE,OAAO,sBAAsB,MAAM,0BAA0B,CAAC;AAC9D,OAAO,iBAAiB,MAAM,qBAAqB,CAAC;AACpD,OAAO,YAAY,MAAM,gBAAgB,CAAC;AAC1C,OAAO,aAAa,MAAM,iBAAiB,CAAC;AAC5C,OAAO,QAAQ,MAAM,YAAY,CAAC;AAClC,OAAO,mBAAmB,MAAM,uBAAuB,CAAC;AACxD,OAAO,cAAc,MAAM,kBAAkB,CAAC;AAC9C,OAAO,wBAAwB,MAAM,4BAA4B,CAAC;AAClE,OAAO,UAAU,MAAM,cAAc,CAAC;AACtC,OAAO,YAAY,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EACL,mBAAmB,EACnB,eAAe,EACf,wBAAwB,EACxB,sBAAsB,EACtB,iBAAiB,EACjB,YAAY,EACZ,aAAa,EACb,QAAQ,EACR,mBAAmB,EACnB,cAAc,EACd,wBAAwB,EACxB,UAAU,EACV,YAAY,GACb,CAAC"}

package/lib/schema/isFilesArray.d.ts

@@ -0,0 +1,10 @@
+import { FormContextType, RJSFSchema, StrictRJSFSchema, UiSchema, ValidatorType } from '../types';
+/** Checks to see if the `schema` and `uiSchema` combination represents an array of files
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which check for array of files flag is desired
+ * @param [uiSchema={}] - The UI schema from which to check the widget
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @returns - True if schema/uiSchema contains an array of files, otherwise false
+ */
+export default 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;

package/lib/schema/isFilesArray.js

@@ -0,0 +1,21 @@
+import { UI_WIDGET_KEY } from '../constants';
+import retrieveSchema from './retrieveSchema';
+/** Checks to see if the `schema` and `uiSchema` combination represents an array of files
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which check for array of files flag is desired
+ * @param [uiSchema={}] - The UI schema from which to check the widget
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @returns - True if schema/uiSchema contains an array of files, otherwise false
+ */
+export default function isFilesArray(validator, schema, uiSchema = {}, rootSchema) {
+    if (uiSchema[UI_WIDGET_KEY] === 'files') {
+        return true;
+    }
+    if (schema.items) {
+        const itemsSchema = retrieveSchema(validator, schema.items, rootSchema);
+        return itemsSchema.type === 'string' && itemsSchema.format === 'data-url';
+    }
+    return false;
+}
+//# sourceMappingURL=isFilesArray.js.map

package/lib/schema/isFilesArray.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isFilesArray.js","sourceRoot":"","sources":["../../src/schema/isFilesArray.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,OAAO,cAAc,MAAM,kBAAkB,CAAC;AAE9C;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,SAAiC,EACjC,MAAS,EACT,WAA8B,EAAE,EAChC,UAAc;IAEd,IAAI,QAAQ,CAAC,aAAa,CAAC,KAAK,OAAO,EAAE;QACvC,OAAO,IAAI,CAAC;KACb;IACD,IAAI,MAAM,CAAC,KAAK,EAAE;QAChB,MAAM,WAAW,GAAG,cAAc,CAAU,SAAS,EAAE,MAAM,CAAC,KAAU,EAAE,UAAU,CAAC,CAAC;QACtF,OAAO,WAAW,CAAC,IAAI,KAAK,QAAQ,IAAI,WAAW,CAAC,MAAM,KAAK,UAAU,CAAC;KAC3E;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/lib/schema/isMultiSelect.d.ts

@@ -0,0 +1,9 @@
+import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+/** Checks to see if the `schema` combination represents a multi-select
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which check for a multi-select flag is desired
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @returns - True if schema contains a multi-select, otherwise false
+ */
+export default function isMultiSelect<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema?: S): boolean;

package/lib/schema/isMultiSelect.js

@@ -0,0 +1,15 @@
+import isSelect from './isSelect';
+/** Checks to see if the `schema` combination represents a multi-select
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param schema - The schema for which check for a multi-select flag is desired
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @returns - True if schema contains a multi-select, otherwise false
+ */
+export default function isMultiSelect(validator, schema, rootSchema) {
+    if (!schema.uniqueItems || !schema.items || typeof schema.items === 'boolean') {
+        return false;
+    }
+    return isSelect(validator, schema.items, rootSchema);
+}
+//# sourceMappingURL=isMultiSelect.js.map

package/lib/schema/isMultiSelect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isMultiSelect.js","sourceRoot":"","sources":["../../src/schema/isMultiSelect.ts"],"names":[],"mappings":"AAEA,OAAO,QAAQ,MAAM,YAAY,CAAC;AAElC;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAInC,SAAiC,EAAE,MAAS,EAAE,UAAc;IAC5D,IAAI,CAAC,MAAM,CAAC,WAAW,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,OAAO,MAAM,CAAC,KAAK,KAAK,SAAS,EAAE;QAC7E,OAAO,KAAK,CAAC;KACd;IACD,OAAO,QAAQ,CAAU,SAAS,EAAE,MAAM,CAAC,KAAU,EAAE,UAAU,CAAC,CAAC;AACrE,CAAC"}

package/lib/schema/isSelect.d.ts

@@ -0,0 +1,9 @@
+import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+/** Checks to see if the `schema` combination represents a select
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param theSchema - The schema for which check for a select flag is desired
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @returns - True if schema contains a select, otherwise false
+ */
+export default function isSelect<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, theSchema: S, rootSchema?: S): boolean;

package/lib/schema/isSelect.js

@@ -0,0 +1,21 @@
+import isConstant from '../isConstant';
+import retrieveSchema from './retrieveSchema';
+/** Checks to see if the `schema` combination represents a select
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param theSchema - The schema for which check for a select flag is desired
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
+ * @returns - True if schema contains a select, otherwise false
+ */
+export default function isSelect(validator, theSchema, rootSchema = {}) {
+    const schema = retrieveSchema(validator, theSchema, rootSchema, undefined);
+    const altSchemas = schema.oneOf || schema.anyOf;
+    if (Array.isArray(schema.enum)) {
+        return true;
+    }
+    if (Array.isArray(altSchemas)) {
+        return altSchemas.every((altSchemas) => typeof altSchemas !== 'boolean' && isConstant(altSchemas));
+    }
+    return false;
+}
+//# sourceMappingURL=isSelect.js.map

package/lib/schema/isSelect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSelect.js","sourceRoot":"","sources":["../../src/schema/isSelect.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,eAAe,CAAC;AAEvC,OAAO,cAAc,MAAM,kBAAkB,CAAC;AAE9C;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC9B,SAAiC,EACjC,SAAY,EACZ,aAAgB,EAAO;IAEvB,MAAM,MAAM,GAAG,cAAc,CAAU,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;IACpF,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,KAAK,CAAC;IAChD,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;QAC9B,OAAO,IAAI,CAAC;KACb;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;QAC7B,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,OAAO,UAAU,KAAK,SAAS,IAAI,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC;KACpG;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/lib/schema/mergeValidationData.d.ts

@@ -0,0 +1,14 @@
+import { ErrorSchema, FormContextType, RJSFSchema, StrictRJSFSchema, ValidationData, ValidatorType } from '../types';
+/** Merges the errors in `additionalErrorSchema` into the existing `validationData` by combining the hierarchies in the
+ * two `ErrorSchema`s and then appending the error list from the `additionalErrorSchema` obtained by calling
+ * `validator.toErrorList()` onto the `errors` in the `validationData`. If no `additionalErrorSchema` is passed, then
+ * `validationData` is returned.
+ *
+ * @param validator - The validator used to convert an ErrorSchema to a list of errors
+ * @param validationData - The current `ValidationData` into which to merge the additional errors
+ * @param [additionalErrorSchema] - The additional set of errors in an `ErrorSchema`
+ * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided.
+ * @deprecated - Use the `validationDataMerge()` function exported from `@rjsf/utils` instead. This function will be
+ *        removed in the next major release.
+ */
+export default 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>;

package/lib/schema/mergeValidationData.js

@@ -0,0 +1,28 @@
+import isEmpty from 'lodash/isEmpty';
+import mergeObjects from '../mergeObjects';
+/** Merges the errors in `additionalErrorSchema` into the existing `validationData` by combining the hierarchies in the
+ * two `ErrorSchema`s and then appending the error list from the `additionalErrorSchema` obtained by calling
+ * `validator.toErrorList()` onto the `errors` in the `validationData`. If no `additionalErrorSchema` is passed, then
+ * `validationData` is returned.
+ *
+ * @param validator - The validator used to convert an ErrorSchema to a list of errors
+ * @param validationData - The current `ValidationData` into which to merge the additional errors
+ * @param [additionalErrorSchema] - The additional set of errors in an `ErrorSchema`
+ * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided.
+ * @deprecated - Use the `validationDataMerge()` function exported from `@rjsf/utils` instead. This function will be
+ *        removed in the next major release.
+ */
+export default function mergeValidationData(validator, validationData, additionalErrorSchema) {
+    if (!additionalErrorSchema) {
+        return validationData;
+    }
+    const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData;
+    let errors = validator.toErrorList(additionalErrorSchema);
+    let errorSchema = additionalErrorSchema;
+    if (!isEmpty(oldErrorSchema)) {
+        errorSchema = mergeObjects(oldErrorSchema, additionalErrorSchema, true);
+        errors = [...oldErrors].concat(errors);
+    }
+    return { errorSchema, errors };
+}
+//# sourceMappingURL=mergeValidationData.js.map

package/lib/schema/mergeValidationData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeValidationData.js","sourceRoot":"","sources":["../../src/schema/mergeValidationData.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,gBAAgB,CAAC;AAErC,OAAO,YAAY,MAAM,iBAAiB,CAAC;AAG3C;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAKzC,SAAiC,EACjC,cAAiC,EACjC,qBAAsC;IAEtC,IAAI,CAAC,qBAAqB,EAAE;QAC1B,OAAO,cAAc,CAAC;KACvB;IACD,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,cAAc,EAAE,GAAG,cAAc,CAAC;IAC1E,IAAI,MAAM,GAAG,SAAS,CAAC,WAAW,CAAC,qBAAqB,CAAC,CAAC;IAC1D,IAAI,WAAW,GAAG,qBAAqB,CAAC;IACxC,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE;QAC5B,WAAW,GAAG,YAAY,CAAC,cAAc,EAAE,qBAAqB,EAAE,IAAI,CAAmB,CAAC;QAC1F,MAAM,GAAG,CAAC,GAAG,SAAS,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;KACxC;IACD,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC;AACjC,CAAC"}

package/lib/schema/retrieveSchema.d.ts

@@ -0,0 +1,170 @@
+import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '../types';
+/** Retrieves an expanded schema that has had all of its conditions, additional properties, references and dependencies
+ * resolved and merged into the `schema` given a `validator`, `rootSchema` and `rawFormData` that is used to do the
+ * potentially recursive resolution.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param schema - The schema for which retrieving a schema is desired
+ * @param [rootSchema={}] - The root schema that will be forwarded to all the APIs
+ * @param [rawFormData] - The current formData, if any, to assist retrieving a schema
+ * @returns - The schema having its conditions, additional properties, references and dependencies resolved
+ */
+export default function retrieveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema?: S, rawFormData?: T): S;
+/** Resolves a conditional block (if/else/then) by removing the condition and merging the appropriate conditional branch
+ * with the rest of the schema. If `expandAllBranches` is true, then the `retrieveSchemaInteral()` results for both
+ * conditions will be returned.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that is used to detect valid schema conditions
+ * @param schema - The schema for which resolving a condition is desired
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and
+ *          dependencies as a list of schemas
+ * @param [formData] - The current formData to assist retrieving a schema
+ * @returns - A list of schemas with the appropriate conditions resolved, possibly with all branches expanded
+ */
+export declare function resolveCondition<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, expandAllBranches: boolean, formData?: T): S[];
+/** Given a list of lists of allOf, anyOf or oneOf values, create a list of lists of all permutations of the values. The
+ * `listOfLists` is expected to be all resolved values of the 1st...nth schemas within an `allOf`, `anyOf` or `oneOf`.
+ * From those lists, build a matrix for each `xxxOf` where there is more than one schema for a row in the list of lists.
+ *
+ * For example:
+ * - If there are three xxxOf rows (A, B, C) and they have been resolved such that there is only one A, two B and three
+ *   C schemas then:
+ *   - The permutation for the first row is `[[A]]`
+ *   - The permutations for the second row are `[[A,B1], [A,B2]]`
+ *   - The permutations for the third row are `[[A,B1,C1], [A,B1,C2], [A,B1,C3], [A,B2,C1], [A,B2,C2], [A,B2,C3]]`
+ *
+ * @param listOfLists - The list of lists of elements that represent the allOf, anyOf or oneOf resolved values in order
+ * @returns - The list of all permutations of schemas for a set of `xxxOf`s
+ */
+export declare function getAllPermutationsOfXxxOf<S extends StrictRJSFSchema = RJSFSchema>(listOfLists: S[][]): S[][];
+/** Resolves references and dependencies within a schema and its 'allOf' children. Passes the `expandAllBranches` flag
+ * down to the `retrieveSchemaInternal()`, `resolveReference()` and `resolveDependencies()` helper calls. If
+ * `expandAllBranches` is true, then all possible dependencies and/or allOf branches are returned.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param schema - The schema for which resolving a schema is desired
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
+ *          as a list of schemas
+ * @param [formData] - The current formData, if any, to assist retrieving a schema
+ * @returns - The list of schemas having its references, dependencies and allOf schemas resolved
+ */
+export declare function resolveSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, expandAllBranches: boolean, formData?: T): S[];
+/** Resolves references within a schema and then returns the `retrieveSchemaInternal()` of the resolved schema. Passes
+ * the `expandAllBranches` flag down to the `retrieveSchemaInternal()` helper call.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param schema - The schema for which resolving a reference is desired
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
+ *          as a list of schemas
+ * @param [formData] - The current formData, if any, to assist retrieving a schema
+ * @returns - The list schemas retrieved after having all references resolved
+ */
+export declare function resolveReference<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, expandAllBranches: boolean, formData?: T): S[];
+/** Resolves all references within a schema's properties and array items.
+ *
+ * @param schema - The schema for which resolving all references is desired
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @returns - given schema will all references resolved
+ */
+export declare function resolveAllReferences<S extends StrictRJSFSchema = RJSFSchema>(schema: S, rootSchema: S): S;
+/** Creates new 'properties' items for each key in the `formData`
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
+ * @param theSchema - The schema for which the existing additional properties is desired
+ * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s * @param validator
+ * @param [aFormData] - The current formData, if any, to assist retrieving a schema
+ * @returns - The updated schema with additional properties stubbed
+ */
+export declare function stubExistingAdditionalProperties<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, theSchema: S, rootSchema?: S, aFormData?: T): S;
+/** Internal handler that 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. If `expandAllBranches` is true, then all possible branches
+ * of the schema and its references, conditions and dependencies are returned.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param schema - The schema for which retrieving a schema is desired
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @param [rawFormData] - The current formData, if any, to assist retrieving a schema
+ * @param [expandAllBranches=false] - Flag, if true, will return all possible branches of conditions, any/oneOf and
+ *          dependencies as a list of schemas
+ * @returns - The schema(s) resulting from having its conditions, additional properties, references and dependencies
+ *          resolved. Multiple schemas may be returned if `expandAllBranches` is true.
+ */
+export declare function retrieveSchemaInternal<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, rawFormData?: T, expandAllBranches?: boolean): S[];
+/** Resolves an `anyOf` or `oneOf` within a schema (if present) to the list of schemas returned from
+ * `retrieveSchemaInternal()` for the best matching option. If `expandAllBranches` is true, then a list of schemas for ALL
+ * options are retrieved and returned.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param schema - The schema for which retrieving a schema is desired
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
+ *          as a list of schemas
+ * @param [rawFormData] - The current formData, if any, to assist retrieving a schema, defaults to an empty object
+ * @returns - Either an array containing the best matching option or all options if `expandAllBranches` is true
+ */
+export declare function resolveAnyOrOneOfSchemas<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, expandAllBranches: boolean, rawFormData?: T): S[];
+/** Resolves dependencies within a schema and its 'anyOf/oneOf' children. Passes the `expandAllBranches` flag down to
+ * the `resolveAnyOrOneOfSchema()` and `processDependencies()` helper calls.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param schema - The schema for which resolving a dependency is desired
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
+ *          as a list of schemas
+ * @param [formData] - The current formData, if any, to assist retrieving a schema
+ * @returns - The list of schemas with their dependencies resolved
+ */
+export declare function resolveDependencies<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, expandAllBranches: boolean, formData?: T): S[];
+/** Processes all the `dependencies` recursively into the list of `resolvedSchema`s as needed. Passes the
+ * `expandAllBranches` flag down to the `withDependentSchema()` and the recursive `processDependencies()` helper calls.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param dependencies - The set of dependencies that needs to be processed
+ * @param resolvedSchema - The schema for which processing dependencies is desired
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
+ *          as a list of schemas
+ * @param [formData] - The current formData, if any, to assist retrieving a schema
+ * @returns - The schema with the `dependencies` resolved into it
+ */
+export declare function processDependencies<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, dependencies: S['dependencies'], resolvedSchema: S, rootSchema: S, expandAllBranches: boolean, formData?: T): S[];
+/** Updates a schema with additionally required properties added
+ *
+ * @param schema - The schema for which resolving a dependent properties is desired
+ * @param [additionallyRequired] - An optional array of additionally required names
+ * @returns - The schema with the additional required values merged in
+ */
+export declare function withDependentProperties<S extends StrictRJSFSchema = RJSFSchema>(schema: S, additionallyRequired?: string[]): S;
+/** Merges a dependent schema into the `schema` dealing with oneOfs and references. Passes the `expandAllBranches` flag
+ * down to the `retrieveSchemaInternal()`, `resolveReference()` and `withExactlyOneSubschema()` helper calls.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+ * @param schema - The schema for which resolving a dependent schema is desired
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @param dependencyKey - The key name of the dependency
+ * @param dependencyValue - The potentially dependent schema
+ * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
+ *          as a list of schemas
+ * @param [formData]- The current formData to assist retrieving a schema
+ * @returns - The list of schemas with the dependent schema resolved into them
+ */
+export declare function withDependentSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, dependencyKey: string, dependencyValue: S, expandAllBranches: boolean, formData?: T): S[];
+/** Returns a list of `schema`s with the best choice from the `oneOf` options merged into it. If `expandAllBranches` is
+ * true, then a list of schemas for ALL options are retrieved and returned. Passes the `expandAllBranches` flag down to
+ * the `retrieveSchemaInternal()` helper call.
+ *
+ * @param validator - An implementation of the `ValidatorType` interface that will be used to validate oneOf options
+ * @param schema - The schema for which resolving a oneOf subschema is desired
+ * @param rootSchema - The root schema that will be forwarded to all the APIs
+ * @param dependencyKey - The key name of the oneOf dependency
+ * @param oneOf - The list of schemas representing the oneOf options
+ * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
+ *          as a list of schemas
+ * @param [formData] - The current formData to assist retrieving a schema
+ * @returns - Either an array containing the best matching option or all options if `expandAllBranches` is true
+ */
+export declare function withExactlyOneSubschema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(validator: ValidatorType<T, S, F>, schema: S, rootSchema: S, dependencyKey: string, oneOf: S['oneOf'], expandAllBranches: boolean, formData?: T): S[];