fastapi-rtk 0.1.13 → 0.1.15

package/dist/.external/esm/@jsonforms_core@3.5.1/@jsonforms/core/lib/jsonforms-core.esm.mjs

@@ -0,0 +1,1936 @@
+import isEmpty from "../../../../../../.bundled/jsonforms/esm/_virtual/isEmpty.mjs";
+import startCase from "../../../../../../.bundled/jsonforms/esm/_virtual/startCase.mjs";
+import keys from "../../../../../../.bundled/jsonforms/esm/_virtual/keys.mjs";
+import range from "../../../../../../.bundled/jsonforms/esm/_virtual/range.mjs";
+import get from "../../../../../../.bundled/jsonforms/esm/_virtual/get.mjs";
+import has from "../../../../../../.bundled/jsonforms/esm/_virtual/has.mjs";
+import find from "../../../../../../.bundled/jsonforms/esm/_virtual/find.mjs";
+import isArray from "../../../../../../.bundled/jsonforms/esm/_virtual/isArray.mjs";
+import includes from "../../../../../../.bundled/jsonforms/esm/_virtual/includes.mjs";
+import Ajv from "../../../../../../.bundled/jsonforms/esm/_virtual/ajv.mjs";
+import addFormats from "../../../../../../.bundled/jsonforms/esm/_virtual/index.mjs";
+import filter from "../../../../../../.bundled/jsonforms/esm/_virtual/filter.mjs";
+import isEqual from "../../../../../../.bundled/jsonforms/esm/_virtual/isEqual.mjs";
+import merge from "../../../../../../.bundled/jsonforms/esm/_virtual/merge.mjs";
+import cloneDeep from "../../../../../../.bundled/jsonforms/esm/_virtual/cloneDeep.mjs";
+import setFp from "../../../../../../.bundled/jsonforms/esm/_virtual/set.mjs";
+import unsetFp from "../../../../../../.bundled/jsonforms/esm/_virtual/unset.mjs";
+import isFunction from "../../../../../../.bundled/jsonforms/esm/_virtual/isFunction.mjs";
+import maxBy from "../../../../../../.bundled/jsonforms/esm/_virtual/maxBy.mjs";
+import "../../../../../../.bundled/jsonforms/esm/_virtual/remove.mjs";
+import "../../../../../../.bundled/jsonforms/esm/_virtual/endsWith.mjs";
+import "../../../../../../.bundled/jsonforms/esm/_virtual/last.mjs";
+import "../../../../../../.bundled/jsonforms/esm/_virtual/reduce.mjs";
+import "../../../../../../.bundled/jsonforms/esm/_virtual/toPairs.mjs";
+const ADDITIONAL_PROPERTIES = "additionalProperties";
+const REQUIRED_PROPERTIES = "required";
+const distinct = (properties, discriminator) => {
+  const known = {};
+  return properties.filter((item) => {
+    const discriminatorValue = discriminator(item);
+    if (Object.prototype.hasOwnProperty.call(known, discriminatorValue)) {
+      return false;
+    } else {
+      known[discriminatorValue] = true;
+      return true;
+    }
+  });
+};
+class Gen {
+  constructor(findOption) {
+    this.findOption = findOption;
+    this.schemaObject = (data) => {
+      const props = this.properties(data);
+      const schema = {
+        type: "object",
+        properties: props,
+        additionalProperties: this.findOption(props)(ADDITIONAL_PROPERTIES)
+      };
+      const required = this.findOption(props)(REQUIRED_PROPERTIES);
+      if (required.length > 0) {
+        schema.required = required;
+      }
+      return schema;
+    };
+    this.properties = (data) => {
+      const emptyProps = {};
+      return Object.keys(data).reduce((acc, propName) => {
+        acc[propName] = this.property(data[propName]);
+        return acc;
+      }, emptyProps);
+    };
+    this.property = (data) => {
+      switch (typeof data) {
+        case "string":
+          return { type: "string" };
+        case "boolean":
+          return { type: "boolean" };
+        case "number":
+          if (Number.isInteger(data)) {
+            return { type: "integer" };
+          }
+          return { type: "number" };
+        case "object":
+          if (data == null) {
+            return { type: "null" };
+          }
+          return this.schemaObjectOrArray(data);
+        default:
+          return {};
+      }
+    };
+    this.schemaObjectOrArray = (data) => {
+      if (data instanceof Array) {
+        return this.schemaArray(data);
+      } else {
+        return this.schemaObject(data);
+      }
+    };
+    this.schemaArray = (data) => {
+      if (data.length > 0) {
+        const allProperties = data.map(this.property);
+        const uniqueProperties = distinct(allProperties, (prop) => JSON.stringify(prop));
+        if (uniqueProperties.length === 1) {
+          return {
+            type: "array",
+            items: uniqueProperties[0]
+          };
+        } else {
+          return {
+            type: "array",
+            items: {
+              oneOf: uniqueProperties
+            }
+          };
+        }
+      } else {
+        return {
+          type: "array",
+          items: {}
+        };
+      }
+    };
+  }
+}
+const generateJsonSchema = (instance, options = {}) => {
+  const findOption = (props) => (optionName) => {
+    switch (optionName) {
+      case ADDITIONAL_PROPERTIES:
+        if (Object.prototype.hasOwnProperty.call(options, ADDITIONAL_PROPERTIES)) {
+          return options[ADDITIONAL_PROPERTIES];
+        }
+        return true;
+      case REQUIRED_PROPERTIES:
+        if (Object.prototype.hasOwnProperty.call(options, REQUIRED_PROPERTIES)) {
+          return options[REQUIRED_PROPERTIES](props);
+        }
+        return Object.keys(props);
+      default:
+        return;
+    }
+  };
+  const gen = new Gen(findOption);
+  return gen.schemaObject(instance);
+};
+const usedIds = /* @__PURE__ */ new Set();
+const makeId = (idBase, iteration) => iteration <= 1 ? idBase : idBase + iteration.toString();
+const isUniqueId = (idBase, iteration) => {
+  const newID = makeId(idBase, iteration);
+  return !usedIds.has(newID);
+};
+const createId = (proposedId) => {
+  if (proposedId === void 0) {
+    proposedId = "undefined";
+  }
+  let tries = 0;
+  while (!isUniqueId(proposedId, tries)) {
+    tries++;
+  }
+  const newID = makeId(proposedId, tries);
+  usedIds.add(newID);
+  return newID;
+};
+const removeId = (id) => usedIds.delete(id);
+const compose = (path1, path2) => {
+  let p1 = path1;
+  if (!isEmpty(path1) && !isEmpty(path2) && !path2.startsWith("[")) {
+    p1 = path1 + ".";
+  }
+  if (isEmpty(p1)) {
+    return path2;
+  } else if (isEmpty(path2)) {
+    return p1;
+  } else {
+    return `${p1}${path2}`;
+  }
+};
+const toDataPathSegments = (schemaPath) => {
+  const s = schemaPath.replace(/(anyOf|allOf|oneOf)\/[\d]+\//g, "").replace(/(then|else)\//g, "");
+  const segments = s.split("/");
+  const decodedSegments = segments.map(decode);
+  const startFromRoot = decodedSegments[0] === "#" || decodedSegments[0] === "";
+  const startIndex = startFromRoot ? 2 : 1;
+  return range(startIndex, decodedSegments.length, 2).map((idx) => decodedSegments[idx]);
+};
+const encode = (segment) => segment == null ? void 0 : segment.replace(/~/g, "~0").replace(/\//g, "~1");
+const decode = (pointerSegment) => pointerSegment == null ? void 0 : pointerSegment.replace(/~1/g, "/").replace(/~0/, "~");
+const deriveLabel = (controlElement, schemaElement) => {
+  if (schemaElement && typeof schemaElement.title === "string") {
+    return schemaElement.title;
+  }
+  if (typeof controlElement.scope === "string") {
+    const ref = controlElement.scope;
+    const label = decode(ref.substr(ref.lastIndexOf("/") + 1));
+    return startCase(label);
+  }
+  return "";
+};
+const createLabelDescriptionFrom = (withLabel, schema) => {
+  const labelProperty = withLabel.label;
+  if (typeof labelProperty === "boolean") {
+    return labelDescription(deriveLabel(withLabel, schema), labelProperty);
+  }
+  if (typeof labelProperty === "string") {
+    return labelDescription(labelProperty, true);
+  }
+  if (typeof labelProperty === "object") {
+    const label = typeof labelProperty.text === "string" ? labelProperty.text : deriveLabel(withLabel, schema);
+    const show = typeof labelProperty.show === "boolean" ? labelProperty.show : true;
+    return labelDescription(label, show);
+  }
+  return labelDescription(deriveLabel(withLabel, schema), true);
+};
+const labelDescription = (text, show) => ({
+  text,
+  show
+});
+const resolveData = (instance, dataPath) => {
+  if (isEmpty(dataPath)) {
+    return instance;
+  }
+  const dataPathSegments = dataPath.split(".");
+  return dataPathSegments.reduce((curInstance, decodedSegment) => {
+    if (!curInstance || !Object.prototype.hasOwnProperty.call(curInstance, decodedSegment)) {
+      return void 0;
+    }
+    return curInstance[decodedSegment];
+  }, instance);
+};
+const invalidSegment = (pathSegment) => pathSegment === "#" || pathSegment === void 0 || pathSegment === "";
+const resolveSchema = (schema, schemaPath, rootSchema) => {
+  const segments = schemaPath == null ? void 0 : schemaPath.split("/").map(decode);
+  return resolveSchemaWithSegments(schema, segments, rootSchema);
+};
+const resolveSchemaWithSegments = (schema, pathSegments, rootSchema) => {
+  if (isEmpty(schema)) {
+    return void 0;
+  }
+  if (typeof schema.$ref === "string") {
+    schema = resolveSchema(rootSchema, schema.$ref, rootSchema);
+  }
+  if (!pathSegments || pathSegments.length === 0) {
+    return schema;
+  }
+  const [segment, ...remainingSegments] = pathSegments;
+  if (invalidSegment(segment)) {
+    return resolveSchemaWithSegments(schema, remainingSegments, rootSchema);
+  }
+  const singleSegmentResolveSchema = get(schema, segment);
+  const resolvedSchema = resolveSchemaWithSegments(singleSegmentResolveSchema, remainingSegments, rootSchema);
+  if (resolvedSchema) {
+    return resolvedSchema;
+  }
+  if (segment === "properties" || segment === "items") {
+    let alternativeResolveResult = void 0;
+    const subSchemas = [].concat(schema.oneOf ?? [], schema.allOf ?? [], schema.anyOf ?? [], schema.then ?? [], schema.else ?? []);
+    for (const subSchema of subSchemas) {
+      alternativeResolveResult = resolveSchemaWithSegments(subSchema, [segment, ...remainingSegments], rootSchema);
+      if (alternativeResolveResult) {
+        break;
+      }
+    }
+    return alternativeResolveResult;
+  }
+  return void 0;
+};
+var RuleEffect;
+(function(RuleEffect2) {
+  RuleEffect2["HIDE"] = "HIDE";
+  RuleEffect2["SHOW"] = "SHOW";
+  RuleEffect2["ENABLE"] = "ENABLE";
+  RuleEffect2["DISABLE"] = "DISABLE";
+})(RuleEffect || (RuleEffect = {}));
+const composeWithUi = (scopableUi, path) => {
+  if (!isScoped(scopableUi)) {
+    return path ?? "";
+  }
+  const segments = toDataPathSegments(scopableUi.scope);
+  if (isEmpty(segments)) {
+    return path ?? "";
+  }
+  return compose(path, segments.join("."));
+};
+const isInternationalized = (element) => typeof element === "object" && element !== null && typeof element.i18n === "string";
+const isGroup = (layout) => layout.type === "Group";
+const isLayout = (uischema) => uischema.elements !== void 0;
+const isScopable = (obj) => !!obj && typeof obj === "object";
+const isScoped = (obj) => isScopable(obj) && typeof obj.scope === "string";
+const isLabelable = (obj) => !!obj && typeof obj === "object";
+const isOrCondition = (condition) => condition.type === "OR";
+const isAndCondition = (condition) => condition.type === "AND";
+const isLeafCondition = (condition) => condition.type === "LEAF";
+const isSchemaCondition = (condition) => has(condition, "schema");
+const getConditionScope = (condition, path) => {
+  return composeWithUi(condition, path);
+};
+const evaluateCondition = (data, condition, path, ajv) => {
+  if (isAndCondition(condition)) {
+    return condition.conditions.reduce((acc, cur) => acc && evaluateCondition(data, cur, path, ajv), true);
+  } else if (isOrCondition(condition)) {
+    return condition.conditions.reduce((acc, cur) => acc || evaluateCondition(data, cur, path, ajv), false);
+  } else if (isLeafCondition(condition)) {
+    const value = resolveData(data, getConditionScope(condition, path));
+    return value === condition.expectedValue;
+  } else if (isSchemaCondition(condition)) {
+    const value = resolveData(data, getConditionScope(condition, path));
+    if (condition.failWhenUndefined && value === void 0) {
+      return false;
+    }
+    return ajv.validate(condition.schema, value);
+  } else {
+    return true;
+  }
+};
+const isRuleFulfilled = (uischema, data, path, ajv) => {
+  const condition = uischema.rule.condition;
+  return evaluateCondition(data, condition, path, ajv);
+};
+const evalVisibility = (uischema, data, path = void 0, ajv) => {
+  const fulfilled = isRuleFulfilled(uischema, data, path, ajv);
+  switch (uischema.rule.effect) {
+    case RuleEffect.HIDE:
+      return !fulfilled;
+    case RuleEffect.SHOW:
+      return fulfilled;
+    default:
+      return true;
+  }
+};
+const evalEnablement = (uischema, data, path = void 0, ajv) => {
+  const fulfilled = isRuleFulfilled(uischema, data, path, ajv);
+  switch (uischema.rule.effect) {
+    case RuleEffect.DISABLE:
+      return !fulfilled;
+    case RuleEffect.ENABLE:
+      return fulfilled;
+    default:
+      return true;
+  }
+};
+const hasShowRule = (uischema) => {
+  if (uischema.rule && (uischema.rule.effect === RuleEffect.SHOW || uischema.rule.effect === RuleEffect.HIDE)) {
+    return true;
+  }
+  return false;
+};
+const hasEnableRule = (uischema) => {
+  if (uischema.rule && (uischema.rule.effect === RuleEffect.ENABLE || uischema.rule.effect === RuleEffect.DISABLE)) {
+    return true;
+  }
+  return false;
+};
+const isVisible = (uischema, data, path = void 0, ajv) => {
+  if (uischema.rule) {
+    return evalVisibility(uischema, data, path, ajv);
+  }
+  return true;
+};
+const isEnabled = (uischema, data, path = void 0, ajv) => {
+  if (uischema.rule) {
+    return evalEnablement(uischema, data, path, ajv);
+  }
+  return true;
+};
+const isOneOfEnumSchema = (schema) => !!schema && Object.prototype.hasOwnProperty.call(schema, "oneOf") && schema.oneOf && schema.oneOf.every((s) => s.const !== void 0);
+const isEnumSchema = (schema) => !!schema && typeof schema === "object" && (Object.prototype.hasOwnProperty.call(schema, "enum") || Object.prototype.hasOwnProperty.call(schema, "const"));
+const convertDateToString = (date, format) => {
+  const dateString = date.toISOString();
+  if (format === "date-time") {
+    return dateString;
+  } else if (format === "date") {
+    return dateString.split("T")[0];
+  } else if (format === "time") {
+    return dateString.split("T")[1].split(".")[0];
+  }
+  return dateString;
+};
+const hasType = (jsonSchema, expected) => {
+  return includes(deriveTypes(jsonSchema), expected);
+};
+const deriveTypes = (jsonSchema) => {
+  if (isEmpty(jsonSchema)) {
+    return [];
+  }
+  if (!isEmpty(jsonSchema.type) && typeof jsonSchema.type === "string") {
+    return [jsonSchema.type];
+  }
+  if (isArray(jsonSchema.type)) {
+    return jsonSchema.type;
+  }
+  if (!isEmpty(jsonSchema.properties) || !isEmpty(jsonSchema.additionalProperties)) {
+    return ["object"];
+  }
+  if (!isEmpty(jsonSchema.items)) {
+    return ["array"];
+  }
+  if (!isEmpty(jsonSchema.enum)) {
+    const types = /* @__PURE__ */ new Set();
+    jsonSchema.enum.forEach((enumElement) => {
+      if (typeof enumElement === "string") {
+        types.add("string");
+      } else {
+        deriveTypes(enumElement).forEach((type) => types.add(type));
+      }
+    });
+    return Array.from(types);
+  }
+  if (!isEmpty(jsonSchema.allOf)) {
+    const allOfType = find(jsonSchema.allOf, (schema) => deriveTypes(schema).length !== 0);
+    if (allOfType) {
+      return deriveTypes(allOfType);
+    }
+  }
+  return [];
+};
+const Resolve = {
+  schema: resolveSchema,
+  data: resolveData
+};
+const fromScoped = (scopable) => toDataPathSegments(scopable.scope).join(".");
+const Paths = {
+  compose,
+  fromScoped
+};
+const createAjv = (options) => {
+  const ajv = new Ajv({
+    allErrors: true,
+    verbose: true,
+    strict: false,
+    addUsedSchema: false,
+    ...options
+  });
+  addFormats(ajv);
+  return ajv;
+};
+const validate = (validator, data) => {
+  if (validator === void 0) {
+    return [];
+  }
+  const valid = validator(data);
+  if (valid) {
+    return [];
+  }
+  return validator.errors;
+};
+const getInvalidProperty = (error) => {
+  switch (error.keyword) {
+    case "required":
+    case "dependencies":
+      return error.params.missingProperty;
+    case "additionalProperties":
+      return error.params.additionalProperty;
+    default:
+      return void 0;
+  }
+};
+const getControlPath = (error) => {
+  let controlPath = error.dataPath || error.instancePath || "";
+  controlPath = controlPath.replace(/\//g, ".");
+  const invalidProperty = getInvalidProperty(error);
+  if (invalidProperty !== void 0 && !controlPath.endsWith(invalidProperty)) {
+    controlPath = `${controlPath}.${invalidProperty}`;
+  }
+  controlPath = controlPath.replace(/^./, "");
+  controlPath = decode(controlPath);
+  return controlPath;
+};
+const errorsAt = (instancePath, schema, matchPath) => (errors) => {
+  const combinatorPaths = filter(errors, (error) => error.keyword === "oneOf" || error.keyword === "anyOf").map((error) => getControlPath(error));
+  return filter(errors, (error) => {
+    if (filteredErrorKeywords.indexOf(error.keyword) !== -1 && !isOneOfEnumSchema(error.parentSchema)) {
+      return false;
+    }
+    const controlPath = getControlPath(error);
+    let result = matchPath(controlPath);
+    const parentSchema = error.parentSchema;
+    if (result && !isObjectSchema(parentSchema) && !isOneOfEnumSchema(parentSchema) && combinatorPaths.findIndex((p) => instancePath.startsWith(p)) !== -1) {
+      result = result && isEqual(parentSchema, schema);
+    }
+    return result;
+  });
+};
+const isObjectSchema = (schema) => {
+  return (schema == null ? void 0 : schema.type) === "object" || !!(schema == null ? void 0 : schema.properties);
+};
+const filteredErrorKeywords = [
+  "additionalProperties",
+  "allOf",
+  "anyOf",
+  "oneOf"
+];
+const formatErrorMessage = (errors) => {
+  if (errors === void 0 || errors === null) {
+    return "";
+  }
+  return errors.join("\n");
+};
+const createLayout = (layoutType) => ({
+  type: layoutType,
+  elements: []
+});
+const createControlElement = (ref) => ({
+  type: "Control",
+  scope: ref
+});
+const wrapInLayoutIfNecessary = (uischema, layoutType) => {
+  if (!isEmpty(uischema) && !isLayout(uischema)) {
+    const verticalLayout = createLayout(layoutType);
+    verticalLayout.elements.push(uischema);
+    return verticalLayout;
+  }
+  return uischema;
+};
+const addLabel = (layout, labelName) => {
+  if (!isEmpty(labelName)) {
+    const fixedLabel = startCase(labelName);
+    if (isGroup(layout)) {
+      layout.label = fixedLabel;
+    } else {
+      const label = {
+        type: "Label",
+        text: fixedLabel
+      };
+      layout.elements.push(label);
+    }
+  }
+};
+const isCombinator = (jsonSchema) => {
+  return !isEmpty(jsonSchema) && (!isEmpty(jsonSchema.oneOf) || !isEmpty(jsonSchema.anyOf) || !isEmpty(jsonSchema.allOf));
+};
+const generateUISchema = (jsonSchema, schemaElements, currentRef, schemaName, layoutType, rootSchema) => {
+  if (!isEmpty(jsonSchema) && jsonSchema.$ref !== void 0) {
+    return generateUISchema(resolveSchema(rootSchema, jsonSchema.$ref, rootSchema), schemaElements, currentRef, schemaName, layoutType, rootSchema);
+  }
+  if (isCombinator(jsonSchema)) {
+    const controlObject = createControlElement(currentRef);
+    schemaElements.push(controlObject);
+    return controlObject;
+  }
+  const types = deriveTypes(jsonSchema);
+  if (types.length === 0) {
+    return null;
+  }
+  if (types.length > 1) {
+    const controlObject = createControlElement(currentRef);
+    schemaElements.push(controlObject);
+    return controlObject;
+  }
+  if (currentRef === "#" && types[0] === "object") {
+    const layout = createLayout(layoutType);
+    schemaElements.push(layout);
+    if (jsonSchema.properties && keys(jsonSchema.properties).length > 1) {
+      addLabel(layout, schemaName);
+    }
+    if (!isEmpty(jsonSchema.properties)) {
+      const nextRef = currentRef + "/properties";
+      Object.keys(jsonSchema.properties).map((propName) => {
+        let value = jsonSchema.properties[propName];
+        const ref = `${nextRef}/${encode(propName)}`;
+        if (value.$ref !== void 0) {
+          value = resolveSchema(rootSchema, value.$ref, rootSchema);
+        }
+        generateUISchema(value, layout.elements, ref, propName, layoutType, rootSchema);
+      });
+    }
+    return layout;
+  }
+  switch (types[0]) {
+    case "object":
+    case "array":
+    case "string":
+    case "number":
+    case "integer":
+    case "null":
+    case "boolean": {
+      const controlObject = createControlElement(currentRef);
+      schemaElements.push(controlObject);
+      return controlObject;
+    }
+    default:
+      throw new Error("Unknown type: " + JSON.stringify(jsonSchema));
+  }
+};
+const generateDefaultUISchema = (jsonSchema, layoutType = "VerticalLayout", prefix = "#", rootSchema = jsonSchema) => wrapInLayoutIfNecessary(generateUISchema(jsonSchema, [], prefix, "", layoutType, rootSchema), layoutType);
+const Generate = {
+  jsonSchema: generateJsonSchema,
+  uiSchema: generateDefaultUISchema,
+  controlElement: createControlElement
+};
+const INIT = "jsonforms/INIT";
+const UPDATE_CORE = "jsonforms/UPDATE_CORE";
+const SET_AJV = "jsonforms/SET_AJV";
+const UPDATE_DATA = "jsonforms/UPDATE";
+const UPDATE_ERRORS = "jsonforms/UPDATE_ERRORS";
+const VALIDATE = "jsonforms/VALIDATE";
+const ADD_RENDERER = "jsonforms/ADD_RENDERER";
+const REMOVE_RENDERER = "jsonforms/REMOVE_RENDERER";
+const ADD_CELL = "jsonforms/ADD_CELL";
+const REMOVE_CELL = "jsonforms/REMOVE_CELL";
+const SET_CONFIG = "jsonforms/SET_CONFIG";
+const ADD_UI_SCHEMA = "jsonforms/ADD_UI_SCHEMA";
+const REMOVE_UI_SCHEMA = "jsonforms/REMOVE_UI_SCHEMA";
+const SET_SCHEMA = "jsonforms/SET_SCHEMA";
+const SET_UISCHEMA = "jsonforms/SET_UISCHEMA";
+const SET_VALIDATION_MODE = "jsonforms/SET_VALIDATION_MODE";
+const SET_LOCALE = "jsonforms/SET_LOCALE";
+const SET_TRANSLATOR = "jsonforms/SET_TRANSLATOR";
+const UPDATE_I18N = "jsonforms/UPDATE_I18N";
+const ADD_DEFAULT_DATA = "jsonforms/ADD_DEFAULT_DATA";
+const REMOVE_DEFAULT_DATA = "jsonforms/REMOVE_DEFAULT_DATA";
+const isUpdateArrayContext = (context) => {
+  if (!("type" in context)) {
+    return false;
+  }
+  if (typeof context.type !== "string") {
+    return false;
+  }
+  switch (context.type) {
+    case "ADD": {
+      return "values" in context && Array.isArray(context.values) && context.values.length > 0;
+    }
+    case "REMOVE": {
+      return "indices" in context && Array.isArray(context.indices) && context.indices.length > 0 && context.indices.every((i) => typeof i === "number");
+    }
+    case "MOVE": {
+      return "moves" in context && Array.isArray(context.moves) && context.moves.length > 0 && context.moves.every((m) => typeof m === "object" && m !== null && "from" in m && "to" in m && typeof m.from === "number" && typeof m.to === "number");
+    }
+    default:
+      return false;
+  }
+};
+const init = (data, schema = generateJsonSchema(data), uischema, options) => ({
+  type: INIT,
+  data,
+  schema,
+  uischema: typeof uischema === "object" ? uischema : generateDefaultUISchema(schema),
+  options
+});
+const updateCore = (data, schema, uischema, options) => ({
+  type: UPDATE_CORE,
+  data,
+  schema,
+  uischema,
+  options
+});
+const registerDefaultData = (schemaPath, data) => ({
+  type: ADD_DEFAULT_DATA,
+  schemaPath,
+  data
+});
+const unregisterDefaultData = (schemaPath) => ({
+  type: REMOVE_DEFAULT_DATA,
+  schemaPath
+});
+const setAjv = (ajv) => ({
+  type: SET_AJV,
+  ajv
+});
+const update = (path, updater, context) => ({
+  type: UPDATE_DATA,
+  path,
+  updater,
+  context
+});
+const updateErrors = (errors) => ({
+  type: UPDATE_ERRORS,
+  errors
+});
+const registerRenderer = (tester, renderer) => ({
+  type: ADD_RENDERER,
+  tester,
+  renderer
+});
+const registerCell = (tester, cell) => ({
+  type: ADD_CELL,
+  tester,
+  cell
+});
+const unregisterCell = (tester, cell) => ({
+  type: REMOVE_CELL,
+  tester,
+  cell
+});
+const unregisterRenderer = (tester, renderer) => ({
+  type: REMOVE_RENDERER,
+  tester,
+  renderer
+});
+const setConfig = (config) => ({
+  type: SET_CONFIG,
+  config
+});
+const setValidationMode = (validationMode) => ({
+  type: SET_VALIDATION_MODE,
+  validationMode
+});
+const registerUISchema = (tester, uischema) => {
+  return {
+    type: ADD_UI_SCHEMA,
+    tester,
+    uischema
+  };
+};
+const unregisterUISchema = (tester) => {
+  return {
+    type: REMOVE_UI_SCHEMA,
+    tester
+  };
+};
+const setLocale = (locale) => ({
+  type: SET_LOCALE,
+  locale
+});
+const setSchema = (schema) => ({
+  type: SET_SCHEMA,
+  schema
+});
+const setTranslator = (translator, errorTranslator) => ({
+  type: SET_TRANSLATOR,
+  translator,
+  errorTranslator
+});
+const updateI18n = (locale, translator, errorTranslator) => ({
+  type: UPDATE_I18N,
+  locale,
+  translator,
+  errorTranslator
+});
+const setUISchema = (uischema) => ({
+  type: SET_UISCHEMA,
+  uischema
+});
+var index$1 = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  INIT,
+  UPDATE_CORE,
+  SET_AJV,
+  UPDATE_DATA,
+  UPDATE_ERRORS,
+  VALIDATE,
+  ADD_RENDERER,
+  REMOVE_RENDERER,
+  ADD_CELL,
+  REMOVE_CELL,
+  SET_CONFIG,
+  ADD_UI_SCHEMA,
+  REMOVE_UI_SCHEMA,
+  SET_SCHEMA,
+  SET_UISCHEMA,
+  SET_VALIDATION_MODE,
+  SET_LOCALE,
+  SET_TRANSLATOR,
+  UPDATE_I18N,
+  ADD_DEFAULT_DATA,
+  REMOVE_DEFAULT_DATA,
+  isUpdateArrayContext,
+  init,
+  updateCore,
+  registerDefaultData,
+  unregisterDefaultData,
+  setAjv,
+  update,
+  updateErrors,
+  registerRenderer,
+  registerCell,
+  unregisterCell,
+  unregisterRenderer,
+  setConfig,
+  setValidationMode,
+  registerUISchema,
+  unregisterUISchema,
+  setLocale,
+  setSchema,
+  setTranslator,
+  updateI18n,
+  setUISchema
+});
+const configDefault = {
+  restrict: false,
+  trim: false,
+  showUnfocusedDescription: false,
+  hideRequiredAsterisk: false
+};
+const applyDefaultConfiguration = (config = {}) => merge({}, configDefault, config);
+const configReducer = (state = applyDefaultConfiguration(), action) => {
+  switch (action.type) {
+    case SET_CONFIG:
+      return applyDefaultConfiguration(action.config);
+    default:
+      return state;
+  }
+};
+const initState = {
+  data: {},
+  schema: {},
+  uischema: void 0,
+  errors: [],
+  validator: void 0,
+  ajv: void 0,
+  validationMode: "ValidateAndShow",
+  additionalErrors: []
+};
+const getValidationMode = (state, action) => {
+  if (action && hasValidationModeOption(action.options)) {
+    return action.options.validationMode;
+  }
+  return state.validationMode;
+};
+const hasValidationModeOption = (option) => {
+  if (option) {
+    return option.validationMode !== void 0;
+  }
+  return false;
+};
+const hasAdditionalErrorsOption = (option) => {
+  if (option) {
+    return option.additionalErrors !== void 0;
+  }
+  return false;
+};
+const getAdditionalErrors = (state, action) => {
+  if (action && hasAdditionalErrorsOption(action.options)) {
+    return action.options.additionalErrors;
+  }
+  return state.additionalErrors;
+};
+const getOrCreateAjv = (state, action) => {
+  if (action) {
+    if (hasAjvOption(action.options)) {
+      return action.options.ajv;
+    } else if (action.options !== void 0) {
+      if (isFunction(action.options.compile)) {
+        return action.options;
+      }
+    }
+  }
+  return state.ajv ? state.ajv : createAjv();
+};
+const hasAjvOption = (option) => {
+  if (option) {
+    return option.ajv !== void 0;
+  }
+  return false;
+};
+const coreReducer = (state = initState, action) => {
+  switch (action.type) {
+    case INIT: {
+      const thisAjv = getOrCreateAjv(state, action);
+      const validationMode = getValidationMode(state, action);
+      const v = validationMode === "NoValidation" ? void 0 : thisAjv.compile(action.schema);
+      const e = validate(v, action.data);
+      const additionalErrors = getAdditionalErrors(state, action);
+      return {
+        ...state,
+        data: action.data,
+        schema: action.schema,
+        uischema: action.uischema,
+        additionalErrors,
+        errors: e,
+        validator: v,
+        ajv: thisAjv,
+        validationMode
+      };
+    }
+    case UPDATE_CORE: {
+      const thisAjv = getOrCreateAjv(state, action);
+      const validationMode = getValidationMode(state, action);
+      let validator = state.validator;
+      let errors = state.errors;
+      if (state.schema !== action.schema || state.validationMode !== validationMode || state.ajv !== thisAjv) {
+        validator = validationMode === "NoValidation" ? void 0 : thisAjv.compile(action.schema);
+        errors = validate(validator, action.data);
+      } else if (state.data !== action.data) {
+        errors = validate(validator, action.data);
+      }
+      const additionalErrors = getAdditionalErrors(state, action);
+      const stateChanged = state.data !== action.data || state.schema !== action.schema || state.uischema !== action.uischema || state.ajv !== thisAjv || state.errors !== errors || state.validator !== validator || state.validationMode !== validationMode || state.additionalErrors !== additionalErrors;
+      return stateChanged ? {
+        ...state,
+        data: action.data,
+        schema: action.schema,
+        uischema: action.uischema,
+        ajv: thisAjv,
+        errors: isEqual(errors, state.errors) ? state.errors : errors,
+        validator,
+        validationMode,
+        additionalErrors
+      } : state;
+    }
+    case SET_AJV: {
+      const currentAjv = action.ajv;
+      const validator = state.validationMode === "NoValidation" ? void 0 : currentAjv.compile(state.schema);
+      const errors = validate(validator, state.data);
+      return {
+        ...state,
+        validator,
+        errors
+      };
+    }
+    case SET_SCHEMA: {
+      const needsNewValidator = action.schema && state.ajv && state.validationMode !== "NoValidation";
+      const v = needsNewValidator ? state.ajv.compile(action.schema) : state.validator;
+      const errors = validate(v, state.data);
+      return {
+        ...state,
+        validator: v,
+        schema: action.schema,
+        errors
+      };
+    }
+    case SET_UISCHEMA: {
+      return {
+        ...state,
+        uischema: action.uischema
+      };
+    }
+    case UPDATE_DATA: {
+      if (action.path === void 0 || action.path === null) {
+        return state;
+      } else if (action.path === "") {
+        const result = action.updater(cloneDeep(state.data));
+        const errors = validate(state.validator, result);
+        return {
+          ...state,
+          data: result,
+          errors
+        };
+      } else {
+        const oldData = get(state.data, action.path);
+        const newData = action.updater(cloneDeep(oldData));
+        let newState;
+        if (newData !== void 0) {
+          newState = setFp(action.path, newData, state.data === void 0 ? {} : state.data);
+        } else {
+          newState = unsetFp(action.path, state.data === void 0 ? {} : state.data);
+        }
+        const errors = validate(state.validator, newState);
+        return {
+          ...state,
+          data: newState,
+          errors
+        };
+      }
+    }
+    case UPDATE_ERRORS: {
+      return {
+        ...state,
+        errors: action.errors
+      };
+    }
+    case SET_VALIDATION_MODE: {
+      if (state.validationMode === action.validationMode) {
+        return state;
+      }
+      if (action.validationMode === "NoValidation") {
+        const errors = validate(void 0, state.data);
+        return {
+          ...state,
+          errors,
+          validationMode: action.validationMode
+        };
+      }
+      if (state.validationMode === "NoValidation") {
+        const validator = state.ajv.compile(state.schema);
+        const errors = validate(validator, state.data);
+        return {
+          ...state,
+          validator,
+          errors,
+          validationMode: action.validationMode
+        };
+      }
+      return {
+        ...state,
+        validationMode: action.validationMode
+      };
+    }
+    default:
+      return state;
+  }
+};
+var ArrayTranslationEnum;
+(function(ArrayTranslationEnum2) {
+  ArrayTranslationEnum2["addTooltip"] = "addTooltip";
+  ArrayTranslationEnum2["addAriaLabel"] = "addAriaLabel";
+  ArrayTranslationEnum2["removeTooltip"] = "removeTooltip";
+  ArrayTranslationEnum2["upAriaLabel"] = "upAriaLabel";
+  ArrayTranslationEnum2["downAriaLabel"] = "downAriaLabel";
+  ArrayTranslationEnum2["noSelection"] = "noSelection";
+  ArrayTranslationEnum2["removeAriaLabel"] = "removeAriaLabel";
+  ArrayTranslationEnum2["noDataMessage"] = "noDataMessage";
+  ArrayTranslationEnum2["deleteDialogTitle"] = "deleteDialogTitle";
+  ArrayTranslationEnum2["deleteDialogMessage"] = "deleteDialogMessage";
+  ArrayTranslationEnum2["deleteDialogAccept"] = "deleteDialogAccept";
+  ArrayTranslationEnum2["deleteDialogDecline"] = "deleteDialogDecline";
+  ArrayTranslationEnum2["up"] = "up";
+  ArrayTranslationEnum2["down"] = "down";
+})(ArrayTranslationEnum || (ArrayTranslationEnum = {}));
+const arrayDefaultTranslations = [
+  {
+    key: ArrayTranslationEnum.addTooltip,
+    default: (input) => input ? `Add to ${input}` : "Add"
+  },
+  {
+    key: ArrayTranslationEnum.addAriaLabel,
+    default: (input) => input ? `Add to ${input} button` : "Add button"
+  },
+  { key: ArrayTranslationEnum.removeTooltip, default: () => "Delete" },
+  { key: ArrayTranslationEnum.removeAriaLabel, default: () => "Delete button" },
+  { key: ArrayTranslationEnum.upAriaLabel, default: () => `Move item up` },
+  { key: ArrayTranslationEnum.up, default: () => "Up" },
+  { key: ArrayTranslationEnum.down, default: () => "Down" },
+  { key: ArrayTranslationEnum.downAriaLabel, default: () => `Move item down` },
+  { key: ArrayTranslationEnum.noDataMessage, default: () => "No data" },
+  { key: ArrayTranslationEnum.noSelection, default: () => "No selection" },
+  {
+    key: ArrayTranslationEnum.deleteDialogTitle,
+    default: () => "Confirm Deletion"
+  },
+  {
+    key: ArrayTranslationEnum.deleteDialogMessage,
+    default: () => "Are you sure you want to delete the selected entry?"
+  },
+  { key: ArrayTranslationEnum.deleteDialogAccept, default: () => "Yes" },
+  { key: ArrayTranslationEnum.deleteDialogDecline, default: () => "No" }
+];
+var CombinatorTranslationEnum;
+(function(CombinatorTranslationEnum2) {
+  CombinatorTranslationEnum2["clearDialogTitle"] = "clearDialogTitle";
+  CombinatorTranslationEnum2["clearDialogMessage"] = "clearDialogMessage";
+  CombinatorTranslationEnum2["clearDialogAccept"] = "clearDialogAccept";
+  CombinatorTranslationEnum2["clearDialogDecline"] = "clearDialogDecline";
+})(CombinatorTranslationEnum || (CombinatorTranslationEnum = {}));
+[
+  {
+    key: CombinatorTranslationEnum.clearDialogTitle,
+    default: () => "Clear form?"
+  },
+  {
+    key: CombinatorTranslationEnum.clearDialogMessage,
+    default: () => "Your data will be cleared. Do you want to proceed?"
+  },
+  { key: CombinatorTranslationEnum.clearDialogAccept, default: () => "Yes" },
+  { key: CombinatorTranslationEnum.clearDialogDecline, default: () => "No" }
+];
+const getI18nKeyPrefixBySchema = (schema, uischema) => {
+  if (isInternationalized(uischema)) {
+    return uischema.i18n;
+  }
+  return (schema == null ? void 0 : schema.i18n) ?? void 0;
+};
+const transformPathToI18nPrefix = (path) => {
+  return (path == null ? void 0 : path.split(".").filter((segment) => !/^\d+$/.test(segment)).join(".")) || "root";
+};
+const getI18nKeyPrefix = (schema, uischema, path) => {
+  return getI18nKeyPrefixBySchema(schema, uischema) ?? transformPathToI18nPrefix(path);
+};
+const getI18nKey = (schema, uischema, path, key) => {
+  return `${getI18nKeyPrefix(schema, uischema, path)}.${key}`;
+};
+const addI18nKeyToPrefix = (i18nKeyPrefix, key) => {
+  return `${i18nKeyPrefix}.${key}`;
+};
+const defaultTranslator = (_id, defaultMessage) => defaultMessage;
+const defaultErrorTranslator = (error, t, uischema) => {
+  var _a;
+  const i18nKey = getI18nKey(error.parentSchema, uischema, getControlPath(error), `error.${error.keyword}`);
+  const specializedKeywordMessage = t(i18nKey, void 0, { error });
+  if (specializedKeywordMessage !== void 0) {
+    return specializedKeywordMessage;
+  }
+  const genericKeywordMessage = t(`error.${error.keyword}`, void 0, {
+    error
+  });
+  if (genericKeywordMessage !== void 0) {
+    return genericKeywordMessage;
+  }
+  const messageCustomization = t(error.message, void 0, { error });
+  if (messageCustomization !== void 0) {
+    return messageCustomization;
+  }
+  if (error.keyword === "required" && ((_a = error.message) == null ? void 0 : _a.startsWith("must have required property"))) {
+    return t("is a required property", "is a required property", { error });
+  }
+  return error.message;
+};
+const getCombinedErrorMessage = (errors, et, t, schema, uischema, path) => {
+  if (errors.length > 0 && t) {
+    const customErrorKey = getI18nKey(schema, uischema, path, "error.custom");
+    const specializedErrorMessage = t(customErrorKey, void 0, {
+      schema,
+      uischema,
+      path,
+      errors
+    });
+    if (specializedErrorMessage !== void 0) {
+      return specializedErrorMessage;
+    }
+  }
+  return formatErrorMessage(errors.map((error) => et(error, t, uischema)));
+};
+const deriveLabelForUISchemaElement = (uischema, t) => {
+  if (uischema.label === false) {
+    return void 0;
+  }
+  if ((uischema.label === void 0 || uischema.label === null || uischema.label === true) && !isInternationalized(uischema)) {
+    return void 0;
+  }
+  const stringifiedLabel = typeof uischema.label === "string" ? uischema.label : JSON.stringify(uischema.label);
+  const i18nKeyPrefix = getI18nKeyPrefixBySchema(void 0, uischema);
+  const i18nKey = typeof i18nKeyPrefix === "string" ? `${i18nKeyPrefix}.label` : stringifiedLabel;
+  return t(i18nKey, stringifiedLabel, { uischema });
+};
+const getArrayTranslations = (t, defaultTranslations, i18nKeyPrefix, label) => {
+  const translations = {};
+  defaultTranslations.forEach((controlElement) => {
+    const key = addI18nKeyToPrefix(i18nKeyPrefix, controlElement.key);
+    translations[controlElement.key] = t(key, controlElement.default(label));
+  });
+  return translations;
+};
+const fetchTranslator = (state) => {
+  if (state === void 0) {
+    return defaultTranslator;
+  }
+  return state.translate;
+};
+const fetchErrorTranslator = (state) => {
+  if (state === void 0) {
+    return defaultErrorTranslator;
+  }
+  return state.translateError;
+};
+const getTranslator = () => (state) => fetchTranslator(get(state, "jsonforms.i18n"));
+const getErrorTranslator = () => (state) => fetchErrorTranslator(get(state, "jsonforms.i18n"));
+const defaultJsonFormsI18nState = {
+  locale: "en",
+  translate: defaultTranslator,
+  translateError: defaultErrorTranslator
+};
+const i18nReducer = (state = defaultJsonFormsI18nState, action) => {
+  switch (action.type) {
+    case UPDATE_I18N: {
+      const locale = action.locale ?? defaultJsonFormsI18nState.locale;
+      const translate = action.translator ?? defaultJsonFormsI18nState.translate;
+      const translateError = action.errorTranslator ?? defaultJsonFormsI18nState.translateError;
+      if (locale !== state.locale || translate !== state.translate || translateError !== state.translateError) {
+        return {
+          ...state,
+          locale,
+          translate,
+          translateError
+        };
+      }
+      return state;
+    }
+    case SET_TRANSLATOR:
+      return {
+        ...state,
+        translate: action.translator ?? defaultTranslator,
+        translateError: action.errorTranslator ?? defaultErrorTranslator
+      };
+    case SET_LOCALE:
+      return {
+        ...state,
+        locale: action.locale ?? navigator.languages[0]
+      };
+    default:
+      return state;
+  }
+};
+const NOT_APPLICABLE = -1;
+const isControl = (uischema) => !isEmpty(uischema) && uischema.scope !== void 0;
+const schemaMatches = (predicate) => (uischema, schema, context) => {
+  if (isEmpty(uischema) || !isControl(uischema)) {
+    return false;
+  }
+  if (isEmpty(schema)) {
+    return false;
+  }
+  const schemaPath = uischema.scope;
+  if (isEmpty(schemaPath)) {
+    return false;
+  }
+  let currentDataSchema = schema;
+  if (hasType(schema, "object")) {
+    currentDataSchema = resolveSchema(schema, schemaPath, context == null ? void 0 : context.rootSchema);
+  }
+  if (currentDataSchema === void 0) {
+    return false;
+  }
+  return predicate(currentDataSchema, context == null ? void 0 : context.rootSchema);
+};
+const schemaSubPathMatches = (subPath, predicate) => (uischema, schema, context) => {
+  if (isEmpty(uischema) || !isControl(uischema)) {
+    return false;
+  }
+  const schemaPath = uischema.scope;
+  let currentDataSchema = schema;
+  if (hasType(schema, "object")) {
+    currentDataSchema = resolveSchema(schema, schemaPath, context == null ? void 0 : context.rootSchema);
+  }
+  currentDataSchema = get(currentDataSchema, subPath);
+  if (currentDataSchema === void 0) {
+    return false;
+  }
+  return predicate(currentDataSchema, context == null ? void 0 : context.rootSchema);
+};
+const schemaTypeIs = (expectedType) => schemaMatches((schema) => !isEmpty(schema) && hasType(schema, expectedType));
+const formatIs = (expectedFormat) => schemaMatches((schema) => !isEmpty(schema) && schema.format === expectedFormat && hasType(schema, "string"));
+const uiTypeIs = (expected) => (uischema) => !isEmpty(uischema) && uischema.type === expected;
+const optionIs = (optionName, optionValue) => (uischema) => {
+  if (isEmpty(uischema)) {
+    return false;
+  }
+  const options = uischema.options;
+  return !isEmpty(options) && options[optionName] === optionValue;
+};
+const and = (...testers) => (uischema, schema, context) => testers.reduce((acc, tester) => acc && tester(uischema, schema, context), true);
+const or = (...testers) => (uischema, schema, context) => testers.reduce((acc, tester) => acc || tester(uischema, schema, context), false);
+const rankWith = (rank, tester) => (uischema, schema, context) => {
+  if (tester(uischema, schema, context)) {
+    return rank;
+  }
+  return NOT_APPLICABLE;
+};
+const isBooleanControl = and(uiTypeIs("Control"), schemaTypeIs("boolean"));
+const isObjectControl = and(uiTypeIs("Control"), schemaTypeIs("object"));
+and(uiTypeIs("Control"), schemaMatches((schema) => Object.prototype.hasOwnProperty.call(schema, "allOf")));
+and(uiTypeIs("Control"), schemaMatches((schema) => Object.prototype.hasOwnProperty.call(schema, "anyOf")));
+const isOneOfControl = and(uiTypeIs("Control"), schemaMatches((schema) => Object.prototype.hasOwnProperty.call(schema, "oneOf")));
+const isEnumControl = and(uiTypeIs("Control"), schemaMatches((schema) => isEnumSchema(schema)));
+and(uiTypeIs("Control"), schemaMatches((schema) => isOneOfEnumSchema(schema)));
+const isIntegerControl = and(uiTypeIs("Control"), schemaTypeIs("integer"));
+const isNumberControl = and(uiTypeIs("Control"), schemaTypeIs("number"));
+const isStringControl = and(uiTypeIs("Control"), schemaTypeIs("string"));
+and(uiTypeIs("Control"), optionIs("multi", true));
+const isDateControl = and(uiTypeIs("Control"), or(formatIs("date"), optionIs("format", "date")));
+and(uiTypeIs("Control"), or(formatIs("time"), optionIs("format", "time")));
+const isDateTimeControl = and(uiTypeIs("Control"), or(formatIs("date-time"), optionIs("format", "date-time")));
+const isObjectArray = and(schemaMatches(
+  (schema, rootSchema) => hasType(schema, "array") && !Array.isArray(resolveSchema(schema, "items", rootSchema))
+), schemaSubPathMatches("items", (schema, rootSchema) => {
+  const resolvedSchema = schema.$ref ? resolveSchema(rootSchema, schema.$ref, rootSchema) : schema;
+  return hasType(resolvedSchema, "object");
+}));
+const isObjectArrayControl = and(uiTypeIs("Control"), isObjectArray);
+const isPrimitiveArrayControl = and(uiTypeIs("Control"), schemaMatches(
+  (schema, rootSchema) => deriveTypes(schema).length !== 0 && !Array.isArray(resolveSchema(schema, "items", rootSchema))
+), schemaSubPathMatches("items", (schema, rootSchema) => {
+  const resolvedSchema = schema.$ref ? resolveSchema(rootSchema, schema.$ref, rootSchema) : schema;
+  const types = deriveTypes(resolvedSchema);
+  return types.length === 1 && includes(["integer", "number", "boolean", "string"], types[0]);
+}));
+and(uiTypeIs("Control"), or(schemaTypeIs("number"), schemaTypeIs("integer")), schemaMatches((schema) => Object.prototype.hasOwnProperty.call(schema, "maximum") && Object.prototype.hasOwnProperty.call(schema, "minimum") && Object.prototype.hasOwnProperty.call(schema, "default")), optionIs("slider", true));
+and(uiTypeIs("Control"), schemaTypeIs("integer"), optionIs("format", true));
+const findMatchingUISchema = (state) => (jsonSchema, schemaPath, path) => {
+  const match = maxBy(state, (entry) => entry.tester(jsonSchema, schemaPath, path));
+  if (match !== void 0 && match.tester(jsonSchema, schemaPath, path) !== NOT_APPLICABLE) {
+    return match.uischema;
+  }
+  return void 0;
+};
+const findUISchema = (uischemas, schema, schemaPath, path, fallback = "VerticalLayout", control, rootSchema) => {
+  if (control && control.options && control.options.detail) {
+    if (typeof control.options.detail === "string") {
+      if (control.options.detail.toUpperCase() === "GENERATE") {
+        if (typeof fallback === "function") {
+          return fallback();
+        }
+        return Generate.uiSchema(schema, fallback, void 0, rootSchema);
+      }
+    } else if (typeof control.options.detail === "object") {
+      if (control.options.detail.type && typeof control.options.detail.type === "string") {
+        return control.options.detail;
+      }
+    }
+  }
+  const uiSchema = findMatchingUISchema(uischemas)(schema, schemaPath, path);
+  if (uiSchema === void 0) {
+    if (typeof fallback === "function") {
+      return fallback();
+    }
+    return Generate.uiSchema(schema, fallback, "#", rootSchema);
+  }
+  return uiSchema;
+};
+const defaultMiddleware = (state, action, defaultReducer) => defaultReducer(state, action);
+const getErrorsAt = (instancePath, schema, matchPath) => (state) => {
+  const errors = state.errors ?? [];
+  const additionalErrors = state.additionalErrors ?? [];
+  return errorsAt(instancePath, schema, matchPath)(state.validationMode === "ValidateAndHide" ? additionalErrors : [...errors, ...additionalErrors]);
+};
+const errorAt = (instancePath, schema) => getErrorsAt(instancePath, schema, (path) => path === instancePath);
+const subErrorsAt = (instancePath, schema) => getErrorsAt(instancePath, schema, (path) => path.startsWith(instancePath + "."));
+const getErrorAt = (instancePath, schema) => (state) => {
+  return errorAt(instancePath, schema)(state.jsonforms.core);
+};
+const getSubErrorsAt = (instancePath, schema) => (state) => subErrorsAt(instancePath, schema)(state.jsonforms.core);
+const getData = (state) => extractData(get(state, "jsonforms.core"));
+const getSchema = (state) => extractSchema(get(state, "jsonforms.core"));
+const getUiSchema = (state) => extractUiSchema(get(state, "jsonforms.core"));
+const getAjv = (state) => extractAjv(get(state, "jsonforms.core"));
+const getRenderers = (state) => get(state, "jsonforms.renderers");
+const getCells = (state) => get(state, "jsonforms.cells");
+const extractData = (state) => get(state, "data");
+const extractSchema = (state) => get(state, "schema");
+const extractUiSchema = (state) => get(state, "uischema");
+const extractAjv = (state) => get(state, "ajv");
+const getConfig = (state) => state.jsonforms.config;
+const isInherentlyEnabled = (state, ownProps, uischema, schema, rootData, config) => {
+  var _a, _b, _c;
+  if ((_a = state == null ? void 0 : state.jsonforms) == null ? void 0 : _a.readonly) {
+    return false;
+  }
+  if (uischema && hasEnableRule(uischema)) {
+    return isEnabled(uischema, rootData, ownProps == null ? void 0 : ownProps.path, getAjv(state));
+  }
+  if (typeof ((_b = uischema == null ? void 0 : uischema.options) == null ? void 0 : _b.readonly) === "boolean") {
+    return !uischema.options.readonly;
+  }
+  if (typeof ((_c = uischema == null ? void 0 : uischema.options) == null ? void 0 : _c.readOnly) === "boolean") {
+    return !uischema.options.readOnly;
+  }
+  if (typeof (config == null ? void 0 : config.readonly) === "boolean") {
+    return !config.readonly;
+  }
+  if (typeof (config == null ? void 0 : config.readOnly) === "boolean") {
+    return !config.readOnly;
+  }
+  if ((schema == null ? void 0 : schema.readOnly) === true) {
+    return false;
+  }
+  if (typeof (ownProps == null ? void 0 : ownProps.enabled) === "boolean") {
+    return ownProps.enabled;
+  }
+  return true;
+};
+const move = (array, index, delta) => {
+  const newIndex = index + delta;
+  if (newIndex < 0 || newIndex >= array.length) {
+    return;
+  }
+  const indexes = [index, newIndex].sort((a, b) => a - b);
+  array.splice(indexes[0], 2, array[indexes[1]], array[indexes[0]]);
+};
+const moveUp = (array, toMove) => {
+  move(array, toMove, -1);
+};
+const moveDown = (array, toMove) => {
+  move(array, toMove, 1);
+};
+const isRequired = (schema, schemaPath, rootSchema) => {
+  const pathSegments = schemaPath.split("/");
+  const lastSegment = decode(pathSegments[pathSegments.length - 1]);
+  const nextHigherSchemaSegments = pathSegments.slice(0, pathSegments.length - 2);
+  const nextHigherSchemaPath = nextHigherSchemaSegments.join("/");
+  const nextHigherSchema = Resolve.schema(schema, nextHigherSchemaPath, rootSchema);
+  return nextHigherSchema !== void 0 && nextHigherSchema.required !== void 0 && nextHigherSchema.required.indexOf(lastSegment) !== -1;
+};
+const createDefaultValue = (schema, rootSchema) => {
+  const defaultValue = doCreateDefaultValue(schema, rootSchema);
+  return defaultValue === void 0 ? {} : defaultValue;
+};
+const doCreateDefaultValue = (schema, rootSchema) => {
+  const resolvedSchema = typeof schema.$ref === "string" ? Resolve.schema(rootSchema, schema.$ref, rootSchema) : schema;
+  if (resolvedSchema.default !== void 0) {
+    return extractDefaults(resolvedSchema, rootSchema);
+  }
+  if (hasType(resolvedSchema, "string")) {
+    if (resolvedSchema.format === "date-time" || resolvedSchema.format === "date" || resolvedSchema.format === "time") {
+      return convertDateToString(/* @__PURE__ */ new Date(), resolvedSchema.format);
+    }
+    return "";
+  }
+  if (hasType(resolvedSchema, "integer") || hasType(resolvedSchema, "number")) {
+    return 0;
+  }
+  if (hasType(resolvedSchema, "boolean")) {
+    return false;
+  }
+  if (hasType(resolvedSchema, "array")) {
+    return [];
+  }
+  if (hasType(resolvedSchema, "object")) {
+    return extractDefaults(resolvedSchema, rootSchema);
+  }
+  if (hasType(resolvedSchema, "null")) {
+    return null;
+  }
+  const combinators = ["oneOf", "anyOf", "allOf"];
+  for (const combinator of combinators) {
+    if (schema[combinator] && Array.isArray(schema[combinator])) {
+      const combinatorDefault = createDefaultValueForCombinatorSchema(schema[combinator], rootSchema);
+      if (combinatorDefault !== void 0) {
+        return combinatorDefault;
+      }
+    }
+  }
+  return void 0;
+};
+const createDefaultValueForCombinatorSchema = (combinatorSchemas, rootSchema) => {
+  if (combinatorSchemas.length > 0) {
+    for (const combinatorSchema of combinatorSchemas) {
+      const result = doCreateDefaultValue(combinatorSchema, rootSchema);
+      if (result !== void 0) {
+        return result;
+      }
+    }
+  }
+  return void 0;
+};
+const extractDefaults = (schema, rootSchema) => {
+  if (hasType(schema, "object") && schema.default === void 0) {
+    const result = {};
+    for (const key in schema.properties) {
+      const property = schema.properties[key];
+      const resolvedProperty = property.$ref ? Resolve.schema(rootSchema, property.$ref, rootSchema) : property;
+      if (resolvedProperty && resolvedProperty.default !== void 0) {
+        result[key] = cloneDeep(resolvedProperty.default);
+      }
+    }
+    if (schema.allOf && Array.isArray(schema.allOf)) {
+      schema.allOf.forEach((allOfSchema) => {
+        if (allOfSchema && allOfSchema.properties) {
+          for (const key in allOfSchema.properties) {
+            const property = allOfSchema.properties[key];
+            const resolvedProperty = property.$ref ? Resolve.schema(rootSchema, property.$ref, rootSchema) : property;
+            if (resolvedProperty && resolvedProperty.default !== void 0) {
+              result[key] = cloneDeep(resolvedProperty.default);
+            }
+          }
+        }
+      });
+    }
+    return result;
+  }
+  return cloneDeep(schema.default);
+};
+const enumToEnumOptionMapper = (e, t, i18nKey) => {
+  let label = typeof e === "string" ? e : JSON.stringify(e);
+  if (t) {
+    if (i18nKey) {
+      label = t(`${i18nKey}.${label}`, label);
+    } else {
+      label = t(label, label);
+    }
+  }
+  return { label, value: e };
+};
+const oneOfToEnumOptionMapper = (e, t, fallbackI18nKey) => {
+  let label = e.title ?? (typeof e.const === "string" ? e.const : JSON.stringify(e.const));
+  if (t) {
+    if (e.i18n) {
+      label = t(e.i18n, label);
+    } else if (fallbackI18nKey) {
+      label = t(`${fallbackI18nKey}.${label}`, label);
+    } else {
+      label = t(label, label);
+    }
+  }
+  return {
+    label,
+    value: e.const
+  };
+};
+const mapStateToControlProps = (state, ownProps) => {
+  const { uischema } = ownProps;
+  const rootData = getData(state);
+  const path = composeWithUi(uischema, ownProps.path);
+  const visible = ownProps.visible === void 0 || hasShowRule(uischema) ? isVisible(uischema, rootData, ownProps.path, getAjv(state)) : ownProps.visible;
+  const controlElement = uischema;
+  const id = ownProps.id;
+  const rootSchema = getSchema(state);
+  const required = controlElement.scope !== void 0 && isRequired(ownProps.schema, controlElement.scope, rootSchema);
+  const resolvedSchema = Resolve.schema(ownProps.schema || rootSchema, controlElement.scope, rootSchema);
+  const errors = getErrorAt(path, resolvedSchema)(state);
+  const description = resolvedSchema !== void 0 ? resolvedSchema.description : "";
+  const data = Resolve.data(rootData, path);
+  const labelDesc = createLabelDescriptionFrom(uischema, resolvedSchema);
+  const label = labelDesc.show ? labelDesc.text : "";
+  const config = getConfig(state);
+  const enabled = isInherentlyEnabled(state, ownProps, uischema, resolvedSchema || rootSchema, rootData, config);
+  const schema = resolvedSchema ?? rootSchema;
+  const t = getTranslator()(state);
+  const te = getErrorTranslator()(state);
+  const i18nKeyPrefix = getI18nKeyPrefix(schema, uischema, path);
+  const i18nLabel = t(getI18nKey(schema, uischema, path, "label"), label, {
+    schema,
+    uischema,
+    path,
+    errors
+  });
+  const i18nDescription = t(getI18nKey(schema, uischema, path, "description"), description, { schema, uischema, path, errors });
+  const i18nErrorMessage = getCombinedErrorMessage(errors, te, t, schema, uischema, path);
+  return {
+    data,
+    description: i18nDescription,
+    errors: i18nErrorMessage,
+    label: i18nLabel,
+    visible,
+    enabled,
+    id,
+    path,
+    required,
+    uischema,
+    schema,
+    config: getConfig(state),
+    cells: ownProps.cells || state.jsonforms.cells,
+    rootSchema,
+    i18nKeyPrefix
+  };
+};
+const mapDispatchToControlProps = (dispatch) => ({
+  handleChange(path, value) {
+    dispatch(update(path, () => value));
+  }
+});
+const mapStateToEnumControlProps = (state, ownProps) => {
+  var _a;
+  const props = mapStateToControlProps(state, ownProps);
+  const options = ownProps.options || ((_a = props.schema.enum) == null ? void 0 : _a.map((e) => enumToEnumOptionMapper(e, getTranslator()(state), getI18nKeyPrefix(props.schema, props.uischema, props.path)))) || props.schema.const && [
+    enumToEnumOptionMapper(props.schema.const, getTranslator()(state), getI18nKeyPrefix(props.schema, props.uischema, props.path))
+  ];
+  return {
+    ...props,
+    options
+  };
+};
+const mapStateToOneOfEnumControlProps = (state, ownProps) => {
+  var _a;
+  const props = mapStateToControlProps(state, ownProps);
+  const options = ownProps.options || ((_a = props.schema.oneOf) == null ? void 0 : _a.map((oneOfSubSchema) => oneOfToEnumOptionMapper(oneOfSubSchema, getTranslator()(state), getI18nKeyPrefix(props.schema, props.uischema, props.path))));
+  return {
+    ...props,
+    options
+  };
+};
+const mapStateToMultiEnumControlProps = (state, ownProps) => {
+  var _a;
+  const props = mapStateToControlProps(state, ownProps);
+  let items = props.schema.items;
+  items = items && items.$ref ? resolveSchema(props.rootSchema, items.$ref, props.rootSchema) : items;
+  const options = ownProps.options || (items == null ? void 0 : items.oneOf) && items.oneOf.map((oneOfSubSchema) => {
+    var _a2;
+    return oneOfToEnumOptionMapper(oneOfSubSchema, (_a2 = state.jsonforms.i18n) == null ? void 0 : _a2.translate, getI18nKeyPrefix(props.schema, props.uischema, props.path));
+  }) || ((_a = items == null ? void 0 : items.enum) == null ? void 0 : _a.map((e) => {
+    var _a2;
+    return enumToEnumOptionMapper(e, (_a2 = state.jsonforms.i18n) == null ? void 0 : _a2.translate, getI18nKeyPrefix(props.schema, props.uischema, props.path));
+  }));
+  return {
+    ...props,
+    options
+  };
+};
+const mapStateToControlWithDetailProps = (state, ownProps) => {
+  const { ...props } = mapStateToControlProps(state, ownProps);
+  return {
+    ...props,
+    uischemas: state.jsonforms.uischemas
+  };
+};
+const mapDispatchToArrayControlProps = (dispatch) => ({
+  addItem: (path, value) => () => {
+    dispatch(update(path, (array) => {
+      if (array === void 0 || array === null) {
+        return [value];
+      }
+      array.push(value);
+      return array;
+    }, { type: "ADD", values: [value] }));
+  },
+  removeItems: (path, toDelete) => () => {
+    dispatch(update(path, (array) => {
+      toDelete.sort((a, b) => a - b).reverse().forEach((s) => array.splice(s, 1));
+      return array;
+    }, { type: "REMOVE", indices: toDelete }));
+  },
+  moveUp: (path, toMove) => () => {
+    dispatch(update(path, (array) => {
+      moveUp(array, toMove);
+      return array;
+    }, {
+      type: "MOVE",
+      moves: [{ from: toMove, to: toMove - 1 }]
+    }));
+  },
+  moveDown: (path, toMove) => () => {
+    dispatch(update(path, (array) => {
+      moveDown(array, toMove);
+      return array;
+    }, {
+      type: "MOVE",
+      moves: [{ from: toMove, to: toMove + 1 }]
+    }));
+  }
+});
+const mapDispatchToMultiEnumProps = (dispatch) => ({
+  addItem: (path, value) => {
+    dispatch(update(path, (data) => {
+      if (data === void 0 || data === null) {
+        return [value];
+      }
+      data.push(value);
+      return data;
+    }));
+  },
+  removeItem: (path, toDelete) => {
+    dispatch(update(path, (data) => {
+      const indexInData = data.indexOf(toDelete);
+      data.splice(indexInData, 1);
+      return data;
+    }));
+  }
+});
+const layoutDefaultProps = {
+  visible: true,
+  enabled: true,
+  path: "",
+  direction: "column"
+};
+const getDirection = (uischema) => {
+  if (uischema.type === "HorizontalLayout") {
+    return "row";
+  }
+  if (uischema.type === "VerticalLayout") {
+    return "column";
+  }
+  return layoutDefaultProps.direction;
+};
+const mapStateToLayoutProps = (state, ownProps) => {
+  const rootData = getData(state);
+  const { uischema } = ownProps;
+  const visible = ownProps.visible === void 0 || hasShowRule(uischema) ? isVisible(ownProps.uischema, rootData, ownProps.path, getAjv(state)) : ownProps.visible;
+  const data = Resolve.data(rootData, ownProps.path);
+  const config = getConfig(state);
+  const enabled = isInherentlyEnabled(
+    state,
+    ownProps,
+    uischema,
+    void 0,
+    rootData,
+    config
+  );
+  const t = getTranslator()(state);
+  const label = isLabelable(uischema) ? deriveLabelForUISchemaElement(uischema, t) : void 0;
+  return {
+    ...layoutDefaultProps,
+    renderers: ownProps.renderers || getRenderers(state),
+    cells: ownProps.cells || getCells(state),
+    visible,
+    enabled,
+    path: ownProps.path,
+    data,
+    uischema: ownProps.uischema,
+    schema: ownProps.schema,
+    direction: ownProps.direction ?? getDirection(uischema),
+    config,
+    label
+  };
+};
+const mapStateToJsonFormsRendererProps = (state, ownProps) => {
+  return {
+    renderers: ownProps.renderers || get(state.jsonforms, "renderers"),
+    cells: ownProps.cells || get(state.jsonforms, "cells"),
+    schema: ownProps.schema || getSchema(state),
+    rootSchema: getSchema(state),
+    uischema: ownProps.uischema || getUiSchema(state),
+    path: ownProps.path,
+    enabled: ownProps.enabled,
+    config: getConfig(state)
+  };
+};
+const mapStateToArrayLayoutProps = (state, ownProps) => {
+  const { path, schema, uischema, errors, label, ...props } = mapStateToControlWithDetailProps(state, ownProps);
+  const resolvedSchema = Resolve.schema(schema, "items", props.rootSchema);
+  const t = getTranslator()(state);
+  const childErrors = getCombinedErrorMessage(getSubErrorsAt(path, resolvedSchema)(state), getErrorTranslator()(state), t, void 0, void 0, void 0);
+  const allErrors = errors + (errors.length > 0 && childErrors.length > 0 ? "\n" : "") + childErrors;
+  return {
+    ...props,
+    label,
+    path,
+    uischema,
+    schema: resolvedSchema,
+    arraySchema: schema,
+    data: props.data ? props.data.length : 0,
+    errors: allErrors,
+    minItems: schema.minItems
+  };
+};
+const mapStateToLabelProps = (state, props) => {
+  const { uischema } = props;
+  const visible = props.visible === void 0 || hasShowRule(uischema) ? isVisible(props.uischema, getData(state), props.path, getAjv(state)) : props.visible;
+  const text = uischema.text;
+  const t = getTranslator()(state);
+  const i18nKeyPrefix = getI18nKeyPrefixBySchema(void 0, uischema);
+  const i18nKey = i18nKeyPrefix ? `${i18nKeyPrefix}.text` : text ?? "";
+  const i18nText = t(i18nKey, text, { uischema });
+  return {
+    text: i18nText,
+    visible,
+    config: getConfig(state),
+    renderers: props.renderers || getRenderers(state),
+    cells: props.cells || getCells(state),
+    uischema
+  };
+};
+const mapStateToCellProps = (state, ownProps) => {
+  const { id, schema, path, uischema, renderers, cells } = ownProps;
+  const rootData = getData(state);
+  const visible = ownProps.visible !== void 0 ? ownProps.visible : isVisible(uischema, rootData, void 0, getAjv(state));
+  const rootSchema = getSchema(state);
+  const config = getConfig(state);
+  let enabled;
+  if (state.jsonforms.readonly === true) {
+    enabled = false;
+  } else if (typeof ownProps.enabled === "boolean") {
+    enabled = ownProps.enabled;
+  } else {
+    enabled = isInherentlyEnabled(state, ownProps, uischema, schema || rootSchema, rootData, config);
+  }
+  const t = getTranslator()(state);
+  const te = getErrorTranslator()(state);
+  const errors = getCombinedErrorMessage(getErrorAt(path, schema)(state), te, t, schema, uischema, path);
+  const isValid = isEmpty(errors);
+  return {
+    data: Resolve.data(rootData, path),
+    visible,
+    enabled,
+    id,
+    path,
+    errors,
+    isValid,
+    schema,
+    uischema,
+    config: getConfig(state),
+    rootSchema,
+    renderers,
+    cells
+  };
+};
+const mapStateToDispatchCellProps = (state, ownProps) => {
+  const props = mapStateToCellProps(state, ownProps);
+  const { renderers: _renderers, cells, ...otherOwnProps } = ownProps;
+  return {
+    ...props,
+    ...otherOwnProps,
+    cells: cells || state.jsonforms.cells || []
+  };
+};
+const defaultMapStateToEnumCellProps = (state, ownProps) => {
+  var _a;
+  const props = mapStateToCellProps(state, ownProps);
+  const options = ownProps.options || ((_a = props.schema.enum) == null ? void 0 : _a.map((e) => enumToEnumOptionMapper(e, getTranslator()(state), getI18nKeyPrefix(props.schema, props.uischema, props.path)))) || props.schema.const && [
+    enumToEnumOptionMapper(props.schema.const, getTranslator()(state), getI18nKeyPrefix(props.schema, props.uischema, props.path))
+  ];
+  return {
+    ...props,
+    options
+  };
+};
+const mapStateToOneOfEnumCellProps = (state, ownProps) => {
+  var _a;
+  const props = mapStateToCellProps(state, ownProps);
+  const options = ownProps.options || ((_a = props.schema.oneOf) == null ? void 0 : _a.map((oneOfSubSchema) => oneOfToEnumOptionMapper(oneOfSubSchema, getTranslator()(state), getI18nKeyPrefix(props.schema, props.uischema, props.path))));
+  return {
+    ...props,
+    options
+  };
+};
+export {
+  ADD_CELL,
+  ADD_DEFAULT_DATA,
+  ADD_RENDERER,
+  ADD_UI_SCHEMA,
+  index$1 as Actions,
+  ArrayTranslationEnum,
+  CombinatorTranslationEnum,
+  Generate,
+  INIT,
+  NOT_APPLICABLE,
+  Paths,
+  REMOVE_CELL,
+  REMOVE_DEFAULT_DATA,
+  REMOVE_RENDERER,
+  REMOVE_UI_SCHEMA,
+  Resolve,
+  RuleEffect,
+  SET_AJV,
+  SET_CONFIG,
+  SET_LOCALE,
+  SET_SCHEMA,
+  SET_TRANSLATOR,
+  SET_UISCHEMA,
+  SET_VALIDATION_MODE,
+  UPDATE_CORE,
+  UPDATE_DATA,
+  UPDATE_ERRORS,
+  UPDATE_I18N,
+  VALIDATE,
+  addI18nKeyToPrefix,
+  and,
+  arrayDefaultTranslations,
+  compose,
+  compose as composePaths,
+  composeWithUi,
+  configReducer,
+  convertDateToString,
+  coreReducer,
+  createAjv,
+  createControlElement,
+  createDefaultValue,
+  createId,
+  createLabelDescriptionFrom,
+  decode,
+  defaultErrorTranslator,
+  defaultJsonFormsI18nState,
+  defaultMapStateToEnumCellProps,
+  defaultMiddleware,
+  defaultTranslator,
+  deriveLabelForUISchemaElement,
+  deriveTypes,
+  doCreateDefaultValue,
+  encode,
+  enumToEnumOptionMapper,
+  errorAt,
+  errorsAt,
+  evalEnablement,
+  evalVisibility,
+  extractAjv,
+  extractData,
+  extractDefaults,
+  extractSchema,
+  extractUiSchema,
+  fetchErrorTranslator,
+  fetchTranslator,
+  findMatchingUISchema,
+  findUISchema,
+  formatErrorMessage,
+  formatIs,
+  generateDefaultUISchema,
+  generateJsonSchema,
+  getAdditionalErrors,
+  getAjv,
+  getArrayTranslations,
+  getCells,
+  getCombinedErrorMessage,
+  getConfig,
+  getControlPath,
+  getData,
+  getErrorAt,
+  getErrorTranslator,
+  getI18nKey,
+  getI18nKeyPrefix,
+  getI18nKeyPrefixBySchema,
+  getOrCreateAjv,
+  getRenderers,
+  getSchema,
+  getSubErrorsAt,
+  getTranslator,
+  getUiSchema,
+  getValidationMode,
+  hasEnableRule,
+  hasShowRule,
+  hasType,
+  i18nReducer,
+  init,
+  initState,
+  isBooleanControl,
+  isControl,
+  isDateControl,
+  isDateTimeControl,
+  isEnabled,
+  isEnumControl,
+  isEnumSchema,
+  isGroup,
+  isInherentlyEnabled,
+  isIntegerControl,
+  isInternationalized,
+  isLabelable,
+  isLayout,
+  isNumberControl,
+  isObjectArray,
+  isObjectArrayControl,
+  isObjectControl,
+  isOneOfControl,
+  isOneOfEnumSchema,
+  isPrimitiveArrayControl,
+  isScopable,
+  isScoped,
+  isStringControl,
+  isUpdateArrayContext,
+  isVisible,
+  layoutDefaultProps,
+  mapDispatchToArrayControlProps,
+  mapDispatchToControlProps,
+  mapDispatchToMultiEnumProps,
+  mapStateToArrayLayoutProps,
+  mapStateToCellProps,
+  mapStateToControlProps,
+  mapStateToControlWithDetailProps,
+  mapStateToDispatchCellProps,
+  mapStateToEnumControlProps,
+  mapStateToJsonFormsRendererProps,
+  mapStateToLabelProps,
+  mapStateToLayoutProps,
+  mapStateToMultiEnumControlProps,
+  mapStateToOneOfEnumCellProps,
+  mapStateToOneOfEnumControlProps,
+  moveDown,
+  moveUp,
+  oneOfToEnumOptionMapper,
+  optionIs,
+  or,
+  rankWith,
+  registerCell,
+  registerDefaultData,
+  registerRenderer,
+  registerUISchema,
+  removeId,
+  resolveData,
+  resolveSchema,
+  schemaMatches,
+  schemaSubPathMatches,
+  schemaTypeIs,
+  setAjv,
+  setConfig,
+  setLocale,
+  setSchema,
+  setTranslator,
+  setUISchema,
+  setValidationMode,
+  subErrorsAt,
+  toDataPathSegments,
+  transformPathToI18nPrefix,
+  uiTypeIs,
+  unregisterCell,
+  unregisterDefaultData,
+  unregisterRenderer,
+  unregisterUISchema,
+  update,
+  updateCore,
+  updateErrors,
+  updateI18n,
+  validate
+};