@luomus/laji-form 15.1.90 → 15.1.93

package/lib/components/LajiForm.d.ts

@@ -19,6 +19,9 @@ import RootInstanceService from "../services/root-instance-service";
 import SingletonMapService from "../services/singleton-map-service";
 import { FieldProps, HasMaybeChildren, Lang } from "../types";
 import MultiActiveArrayService from "../services/multi-active-array-service";
+import * as fields from "./fields";
+import * as widgets from "./widgets";
+import * as templates from "./templates";
 export interface LajiFormProps extends HasMaybeChildren {
     apiClient?: ApiClientImplementation;
     lang?: Lang;
@@ -191,17 +194,267 @@ export default class LajiForm extends React.Component<LajiFormProps, LajiFormSta
     getFields: (_fields?: {
         [name: string]: Field;
     }) => {
-        [x: string]: Field;
+        SchemaField: typeof fields.SchemaField;
+        ArrayField: typeof fields.ArrayField;
+        ObjectField: (props: any) => JSX.Element;
+        NestField: typeof fields.NestField;
+        ArrayBulkField: typeof fields.ArrayBulkField;
+        ArrayPropertySumField: typeof fields.ArrayPropertySumField;
+        ScopeField: typeof fields.ScopeField;
+        SelectTreeField: typeof fields.SelectTreeField;
+        GridLayoutField: {
+            (props: any): JSX.Element;
+            propTypes: {
+                uiSchema: PropTypes.Requireable<PropTypes.InferProps<{
+                    "ui:grid": PropTypes.Requireable<PropTypes.InferProps<{
+                        lg: PropTypes.Requireable<NonNullable<number | object | null | undefined>>;
+                        md: PropTypes.Requireable<NonNullable<number | object | null | undefined>>;
+                        sm: PropTypes.Requireable<NonNullable<number | object | null | undefined>>;
+                        xs: PropTypes.Requireable<NonNullable<number | object | null | undefined>>;
+                    }>>;
+                }>>;
+                schema: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                    type: PropTypes.Requireable<string>;
+                }>>>;
+            };
+        };
+        TableField: typeof fields.TableField;
+        InjectField: typeof fields.InjectField;
+        InjectDefaultValueField: typeof fields.InjectDefaultValueField;
+        ArrayCombinerField: typeof fields.ArrayCombinerField;
+        DependentBooleanField: typeof fields.DependentBooleanField;
+        DependentDisableField: typeof fields.DependentDisableField;
+        MapArrayField: typeof fields.MapArrayField;
+        AutoArrayField: typeof fields.AutoArrayField;
+        AutosuggestField: typeof fields.AutosuggestField;
+        HiddenField: {
+            (): JSX.Element;
+            propTypes: {
+                schema: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                    type: PropTypes.Requireable<string>;
+                }>>>;
+            };
+        };
+        HiddenWithTextField: {
+            (props: FieldProps<import("../types").JSONSchemaArray<import("../types").JSONSchemaString>>): JSX.Element;
+            propTypes: {
+                uiSchema: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                    "ui:options": PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                        altText: PropTypes.Validator<string>;
+                    }>>>;
+                    uiSchema: PropTypes.Requireable<object>;
+                }>>>;
+                schema: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                    type: PropTypes.Requireable<string>;
+                }>>>;
+            };
+        };
+        InitiallyHiddenField: typeof fields.InitiallyHiddenField;
+        ContextInjectionField: typeof fields.ContextInjectionField;
+        ImageArrayField: typeof fields.ImageArrayField;
+        SplitField: typeof fields.SplitField;
+        FlatField: typeof fields.FlatField;
+        SingleActiveArrayField: typeof fields.SingleActiveArrayField;
+        SingleItemArrayField: typeof fields.SingleItemArrayField;
+        UnitShorthandField: typeof fields.UnitShorthandField;
+        CombinedValueDisplayField: typeof fields.CombinedValueDisplayField;
+        UiFieldMapperArrayField: typeof fields.UiFieldMapperArrayField;
+        ExtraLabelRowField: typeof fields.ExtraLabelRowField;
+        SumField: typeof fields.SumField;
+        NamedPlaceChooserField: typeof fields.NamedPlaceChooserField;
+        NamedPlaceSaverField: typeof fields.NamedPlaceSaverField;
+        MapField: typeof fields.MapField;
+        GeocoderField: typeof fields.GeocoderField;
+        TagArrayField: typeof fields.TagArrayField;
+        StringToArrayField: typeof fields.StringToArrayField;
+        ConditionalOnChangeField: typeof fields.ConditionalOnChangeField;
+        ConditionalUiSchemaField: typeof fields.ConditionalUiSchemaField;
+        AnnotationField: typeof fields.AnnotationField;
+        PrefillingArrayField: typeof fields.PrefillingArrayField;
+        AnyToBooleanField: {
+            (props: any): JSX.Element;
+            propTypes: {
+                uiSchema: PropTypes.Requireable<PropTypes.InferProps<{
+                    "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                        trueValue: PropTypes.Validator<object>;
+                        falseValue: PropTypes.Requireable<object>;
+                        allowUndefined: PropTypes.Requireable<boolean>;
+                    }>>;
+                }>>;
+                schema: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                    type: PropTypes.Requireable<string>;
+                }>>>;
+                formData: PropTypes.Requireable<object>;
+            };
+        };
+        EnumRangeArrayField: typeof fields.EnumRangeArrayField;
+        UnitListShorthandArrayField: typeof fields.UnitListShorthandArrayField;
+        LocationChooserField: typeof fields.LocationChooserField;
+        DataLeakerField: typeof fields.DataLeakerField;
+        LocalityField: typeof fields.LocalityField;
+        ImageDisplayField: typeof fields.ImageDisplayField;
+        FakePropertyField: typeof fields.FakePropertyField;
+        SectionArrayField: typeof fields.SectionArrayField;
+        MultiArrayField: typeof fields.MultiArrayField;
+        AudioArrayField: typeof fields.AudioArrayField;
+        FilterArrayField: typeof fields.FilterArrayField;
+        MultiAnyToBooleanField: typeof fields.MultiAnyToBooleanField;
+        UnitCountShorthandField: typeof fields.UnitCountShorthandField;
+        ToggleAdditionalArrayFieldsField: typeof fields.ToggleAdditionalArrayFieldsField;
+        DefaultValueArrayField: typeof fields.DefaultValueArrayField;
+        UiFieldApplierField: typeof fields.UiFieldApplierField;
+        MultiLanguageField: typeof fields.MultiLanguageField;
+        SortArrayField: typeof fields.SortArrayField;
+        InputWithDefaultValueButtonField: typeof fields.InputWithDefaultValueButtonField;
+        MultiTagArrayField: typeof fields.MultiTagArrayField;
+        PdfArrayField: typeof fields.PdfArrayField;
+        AsArrayField: typeof fields.AsArrayField;
+        CondensedObjectField: typeof fields.CondensedObjectField;
+        MultiActiveArrayField: typeof fields.MultiActiveArrayField;
+        PrefixArrayField: typeof fields.PrefixArrayField;
+        FillDateRangeField: typeof fields.FillDateRangeField;
+        TaxonSetPopulatorField: typeof fields.TaxonSetPopulatorField;
+        ScientificNameTaxonAutosuggestField: typeof fields.ScientificNameTaxonAutosuggestField;
+        ArraySchemaField: typeof fields.SchemaField;
+        InputTransformerField: typeof fields.ConditionalOnChangeField;
+        ConditionalField: typeof fields.ConditionalUiSchemaField;
+        UnitRapidField: typeof fields.UnitShorthandField;
+        AccordionArrayField: typeof fields.SingleActiveArrayField;
     };
     getWidgets: (_widgets?: {
         [name: string]: Widget;
     }) => {
-        [x: string]: Widget;
+        CheckboxWidget: typeof widgets.CheckboxWidget;
+        SelectWidget: <T extends string | number>(props: (Omit<import("../types").WidgetProps<import("../types").JSONSchemaEnum>, "value" | "onChange"> & {
+            value?: T | undefined;
+            onChange: (value?: T | undefined) => void;
+        } & {
+            includeEmpty?: boolean;
+            getEnumOptionsAsync?: (() => Promise<(Omit<import("@rjsf/utils").EnumOptionsType, "value"> & {
+                value: T;
+            })[]>) | undefined;
+        }) | (Omit<import("../types").WidgetProps<import("../types").JSONSchemaArray<import("../types").JSONSchemaEnumOneOf>>, "value" | "onChange"> & {
+            value?: T[] | undefined;
+            onChange: (value?: T[] | undefined) => void;
+        } & {
+            includeEmpty?: boolean;
+            getEnumOptionsAsync?: (() => Promise<(Omit<import("@rjsf/utils").EnumOptionsType, "value"> & {
+                value: T;
+            })[]>) | undefined;
+        })) => JSX.Element;
+        TextareaWidget: typeof widgets.TextareaWidget;
+        DateTimeWidget: typeof widgets.DateTimeWidget;
+        DateWidget: {
+            (props: any): JSX.Element;
+            propTypes: {
+                uiSchema: PropTypes.Requireable<PropTypes.InferProps<{
+                    "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                        showButtons: PropTypes.Requireable<NonNullable<boolean | PropTypes.InferProps<{
+                            today: PropTypes.Requireable<boolean>;
+                            yesterday: PropTypes.Requireable<boolean>;
+                            same: PropTypes.Requireable<NonNullable<boolean | PropTypes.InferProps<{
+                                path: PropTypes.Requireable<string>;
+                            }> | null | undefined>>;
+                            plusSixMonths: PropTypes.Requireable<NonNullable<boolean | PropTypes.InferProps<{
+                                path: PropTypes.Requireable<string>;
+                            }> | null | undefined>>;
+                            plusSixYear: PropTypes.Requireable<NonNullable<boolean | PropTypes.InferProps<{
+                                path: PropTypes.Requireable<string>;
+                            }> | null | undefined>>;
+                        }> | null | undefined>>;
+                        allowOnlyYear: PropTypes.Requireable<boolean>;
+                    }>>;
+                }>>;
+                schema: PropTypes.Requireable<PropTypes.InferProps<{
+                    type: PropTypes.Requireable<string>;
+                }>>;
+                value: PropTypes.Requireable<string>;
+            };
+        };
+        TimeWidget: {
+            (props: any): JSX.Element;
+            propTypes: {
+                schema: PropTypes.Requireable<PropTypes.InferProps<{
+                    type: PropTypes.Requireable<string>;
+                }>>;
+                value: PropTypes.Requireable<string>;
+            };
+        };
+        SeparatedDateTimeWidget: typeof widgets.SeparatedDateTimeWidget;
+        AutosuggestWidget: typeof widgets.AutosuggestWidget;
+        HiddenWidget: typeof widgets.HiddenWidget;
+        PlainTextWidget: typeof widgets.PlainTextWidget;
+        TextSelectWidget: typeof widgets.TextSelectWidget;
+        ImageSelectWidget: typeof widgets.ImageSelectWidget;
+        AnyToBooleanWidget: {
+            (props: any): JSX.Element;
+            propTypes: {
+                uiSchema: PropTypes.Requireable<PropTypes.InferProps<{
+                    "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                        trueValue: PropTypes.Validator<NonNullable<NonNullable<string | number | boolean | null | undefined>>>;
+                        falseValue: PropTypes.Requireable<NonNullable<string | number | boolean | null | undefined>>;
+                        allowUndefined: PropTypes.Requireable<boolean>;
+                    }>>;
+                }>>;
+                schema: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+                    type: PropTypes.Requireable<string>;
+                }>>>;
+                formData: PropTypes.Requireable<NonNullable<string | number | boolean | null | undefined>>;
+            };
+        };
+        URLWidget: {
+            ({ value, options }: {
+                value: any;
+                options?: {} | undefined;
+            }): JSX.Element;
+            propTypes: {
+                schema: PropTypes.Requireable<PropTypes.InferProps<{
+                    type: PropTypes.Requireable<string>;
+                }>>;
+                value: PropTypes.Requireable<string>;
+            };
+        };
+        InformalTaxonGroupChooserWidget: typeof widgets.InformalTaxonGroupChooserWidget;
+        TaxonImageWidget: typeof widgets.TaxonImageWidget;
+        UpperCaseWidget: typeof widgets.UpperCaseWidget;
+        NumberWidget: typeof widgets.NumberWidget;
+        InputGroupWidget: typeof widgets.InputGroupWidget;
+        InputWithDefaultValueButtonWidget: typeof widgets.InputWithDefaultValueButtonWidget;
     };
     getTemplates: (_templates?: {
         [name: string]: TemplatesType;
     }) => {
-        [x: string]: TemplatesType<any, import("@rjsf/utils").RJSFSchema, any>;
+        BaseInputTemplate: typeof templates.BaseInputTemplate;
+        DescriptionField: typeof templates.DescriptionField;
+        FieldTemplate: typeof templates.FieldTemplate;
+        ArrayFieldTemplate: {
+            new (): {
+                [x: string]: any;
+                componentDidMount(): void;
+                componentDidUpdate(prevProps: any, prevState: any): void;
+                componentWillUnmount(): void;
+                addKeyHandlers(): void;
+                arrayKeyFunctions: any;
+                removeKeyHandlers(props: any): void;
+                getKeyHandlers(props: any): any[];
+                addChildKeyHandlers(props: any): void;
+                childKeyHandlers: any;
+                removeChildKeyHandlers(): void;
+                getChildKeyHandlers(props: any): any;
+                onFocus: (target: any) => void;
+                onCopy: (options?: {}) => void;
+                getCustomEventListeners(): (string | ((target: any) => void))[][];
+                addCustomEventListeners(props: any): void;
+                customEventListeners: any;
+                removeCustomEventListeners(props: any): void;
+            };
+            [x: string]: any;
+            displayName: string;
+        };
+        ErrorListTemplate: typeof templates.ErrorListTemplate;
+        ObjectFieldTemplate: typeof templates.ObjectFieldTemplate;
+        TitleFieldTemplate: (props: any) => JSX.Element | null;
+        DescriptionFieldTemplate: typeof templates.DescriptionField;
     };
     getContext: (props: LajiFormProps, context: ContextProps) => ContextProps;
     render(): JSX.Element | null;

package/lib/components/LajiForm.js

@@ -74,133 +74,9 @@ const id_service_1 = __importDefault(require("../services/id-service"));
 const root_instance_service_1 = __importDefault(require("../services/root-instance-service"));
 const singleton_map_service_1 = __importDefault(require("../services/singleton-map-service"));
 const multi_active_array_service_1 = __importDefault(require("../services/multi-active-array-service"));
-const fields = importLocalComponents("fields", [
-    "SchemaField",
-    { "ArraySchemaField": "SchemaField" },
-    "ArrayField",
-    "ObjectField",
-    "NestField",
-    "ArrayBulkField",
-    "ArrayBulkField",
-    "ArrayPropertySumField",
-    "ScopeField",
-    "SelectTreeField",
-    "GridLayoutField",
-    "TableField",
-    "InjectField",
-    "InjectDefaultValueField",
-    "ArrayCombinerField",
-    "DependentBooleanField",
-    "DependentDisableField",
-    "MapArrayField",
-    "AutoArrayField",
-    "AutosuggestField",
-    "HiddenField",
-    "HiddenWithTextField",
-    "InitiallyHiddenField",
-    "ContextInjectionField",
-    "ImageArrayField",
-    "SplitField",
-    "FlatField",
-    "SingleActiveArrayField",
-    "SingleItemArrayField",
-    "UnitShorthandField",
-    "CombinedValueDisplayField",
-    "UiFieldMapperArrayField",
-    "ExtraLabelRowField",
-    "SumField",
-    "NamedPlaceChooserField",
-    "NamedPlaceSaverField",
-    "MapField",
-    "GeocoderField",
-    "TagArrayField",
-    "StringToArrayField",
-    "ConditionalOnChangeField",
-    "ConditionalUiSchemaField",
-    "AnnotationField",
-    "PrefillingArrayField",
-    "AnyToBooleanField",
-    "EnumRangeArrayField",
-    "UnitListShorthandArrayField",
-    "LocationChooserField",
-    "DataLeakerField",
-    "LocalityField",
-    "ImageDisplayField",
-    "FakePropertyField",
-    "SectionArrayField",
-    "MultiArrayField",
-    "AudioArrayField",
-    "FilterArrayField",
-    "MultiAnyToBooleanField",
-    "UnitCountShorthandField",
-    "ToggleAdditionalArrayFieldsField",
-    "DefaultValueArrayField",
-    "UiFieldApplierField",
-    "MultiLanguageField",
-    "SortArrayField",
-    "InputWithDefaultValueButtonField",
-    "MultiTagArrayField",
-    "PdfArrayField",
-    "AsArrayField",
-    "CondensedObjectField",
-    "MultiActiveArrayField",
-    "PrefixArrayField",
-    "FillDateRangeField",
-    "ScientificNameTaxonAutosuggestField",
-    { "InputTransformerField": "ConditionalOnChangeField" }, // Alias for backward compatibility.
-    { "ConditionalField": "ConditionalUiSchemaField" }, // Alias for backward compatibility.
-    { "UnitRapidField": "UnitShorthandField" }, // Alias for backward compatibility.
-    { "AccordionArrayField": "SingleActiveArrayField" } // Alias for backward compatibility.
-]);
-const widgets = importLocalComponents("widgets", [
-    "CheckboxWidget",
-    "SelectWidget",
-    "TextareaWidget",
-    "DateTimeWidget",
-    "DateWidget",
-    "TimeWidget",
-    "SeparatedDateTimeWidget",
-    "AutosuggestWidget",
-    "HiddenWidget",
-    "PlainTextWidget",
-    "TextSelectWidget",
-    "ImageSelectWidget",
-    "AnyToBooleanWidget",
-    "URLWidget",
-    "InformalTaxonGroupChooserWidget",
-    "TaxonImageWidget",
-    "UpperCaseWidget",
-    "NumberWidget",
-    "InputGroupWidget",
-    "InputWithDefaultValueButtonWidget"
-]);
-const templates = importLocalComponents("templates", [
-    "BaseInputTemplate",
-    "DescriptionField",
-    { "TitleFieldTemplate": "TitleField" },
-    { "DescriptionFieldTemplate": "DescriptionField" },
-    "FieldTemplate",
-    "ArrayFieldTemplate",
-    "ErrorListTemplate",
-    "ObjectFieldTemplate"
-]);
-function importLocalComponents(dir, fieldNames) {
-    return fieldNames.reduce((fields, field) => {
-        if (typeof field === "string") {
-            fields[field] = require(`./${dir}/${field}`).default;
-        }
-        else {
-            const fieldName = Object.keys(field)[0];
-            if (typeof field[fieldName] === "string") {
-                fields[fieldName] = require(`./${dir}/${field[fieldName]}`).default;
-            }
-            else {
-                fields[fieldName] = field[fieldName];
-            }
-        }
-        return fields;
-    }, {});
-}
+const fields = __importStar(require("./fields"));
+const widgets = __importStar(require("./widgets"));
+const templates = __importStar(require("./templates"));
 // Each form should have a unique id to keep Context private.
 let id = 0;
 function getNewId() {

package/lib/components/fields/MultiAnyToBooleanField.d.ts

@@ -22,6 +22,12 @@ export default class MultiAnyToBooleanField extends React.Component<any, any, an
     getInitialState(props: any): {
         groupsFormData: any[];
     };
+    getStateFromProps(props: any): {
+        groupsFormData: any[];
+    };
+    initializeGroups: (props: any) => {
+        groupsFormData: any[];
+    };
     onChange: (index: any) => (value: any) => void;
     render(): JSX.Element;
 }

package/lib/components/fields/MultiAnyToBooleanField.js

@@ -62,6 +62,31 @@ const utils_2 = require("@rjsf/utils");
 let MultiAnyToBooleanField = class MultiAnyToBooleanField extends React.Component {
     constructor(props) {
         super(props);
+        this.initializeGroups = (props) => {
+            let { groups } = (0, utils_1.getUiOptions)(props.uiSchema) || [];
+            const { formData } = props;
+            const trueValues = groups.map(group => group.trueValue);
+            const falseValues = groups.map(group => group.falseValue);
+            const groupsFormData = [];
+            if (formData) {
+                formData.forEach(value => {
+                    if (value === undefined) {
+                        return;
+                    }
+                    const trueIndex = trueValues.findIndex(trueValue => props.formContext.utils.formDataEquals(value, trueValue, props.idSchema.$id));
+                    if (trueIndex !== -1) {
+                        groupsFormData[trueIndex] = value;
+                    }
+                    else {
+                        const falseIndex = falseValues.findIndex(falseValue => props.formContext.utils.formDataEquals(value, falseValue, props.idSchema.$id));
+                        if (falseIndex !== -1) {
+                            groupsFormData[falseIndex] = value;
+                        }
+                    }
+                });
+            }
+            return { groupsFormData: groupsFormData };
+        };
         this.onChange = (index) => (value) => {
             const groupsFormData = this.state.groupsFormData;
             groupsFormData[index] = value;
@@ -77,29 +102,10 @@ let MultiAnyToBooleanField = class MultiAnyToBooleanField extends React.Componen
         this.state = this.getInitialState(props);
     }
     getInitialState(props) {
-        let { groups } = (0, utils_1.getUiOptions)(props.uiSchema) || [];
-        const { formData } = props;
-        const trueValues = groups.map(group => group.trueValue);
-        const falseValues = groups.map(group => group.falseValue);
-        const groupsFormData = [];
-        if (formData) {
-            formData.forEach(value => {
-                if (value === undefined) {
-                    return;
-                }
-                const trueIndex = trueValues.findIndex(trueValue => props.formContext.utils.formDataEquals(value, trueValue, props.idSchema.$id));
-                if (trueIndex !== -1) {
-                    groupsFormData[trueIndex] = value;
-                }
-                else {
-                    const falseIndex = falseValues.findIndex(falseValue => props.formContext.utils.formDataEquals(value, falseValue, props.idSchema.$id));
-                    if (falseIndex !== -1) {
-                        groupsFormData[falseIndex] = value;
-                    }
-                }
-            });
-        }
-        return { groupsFormData: groupsFormData };
+        return this.initializeGroups(props);
+    }
+    getStateFromProps(props) {
+        return this.initializeGroups(props);
     }
     render() {
         const TitleFieldTemplate = (0, utils_2.getTemplate)("TitleFieldTemplate", this.props.registry, (0, utils_1.getUiOptions)(this.props.uiSchema));

package/lib/components/fields/TaxonSetPopulatorField.d.ts

@@ -0,0 +1,50 @@
+import * as React from "react";
+import * as PropTypes from "prop-types";
+import { FieldProps } from "../../types";
+/**
+ * Watches a specified field which contains taxon set IDs.
+ *
+ * When taxon set IDs are added, it fetches the taxa in those sets from the API and adds them to the units in formData.
+ *
+ * When taxon set IDs are removed, it removes any taxa belonging to those sets from the units in formData.
+ *
+ * uiSchema = {
+ *   "ui:field": "TaxonSetPopulatorField",
+ *   "ui:options": {
+ *     "props": {
+ *       "from": "taxonCensus",                    	// Source object containing taxon set IDs
+ *       "fromArrayKey": "censusTaxonSetID",      	// Field within source object containing the taxon set IDs
+ *    	 "joinArray": true,                      	// Join array of IDs into comma-separated string
+ *     }
+ *   }
+ * }
+ */
+export default class TaxonSetPopulatorField extends React.Component<FieldProps> {
+    static propTypes: {
+        uiSchema: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                props: PropTypes.Requireable<NonNullable<PropTypes.InferProps<{
+                    from: PropTypes.Validator<string>;
+                    fromArrayKey: PropTypes.Requireable<string>;
+                    joinArray: PropTypes.Requireable<boolean>;
+                }> | (PropTypes.InferProps<{
+                    from: PropTypes.Validator<string>;
+                    fromArrayKey: PropTypes.Requireable<string>;
+                    joinArray: PropTypes.Requireable<boolean>;
+                }> | null | undefined)[] | null | undefined>>;
+            }>>;
+            uiSchema: PropTypes.Requireable<object>;
+        }>>>;
+        schema: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>>;
+        formData: PropTypes.Validator<object>;
+    };
+    static getName(): string;
+    taxonSets: any[];
+    getStateFromProps(): {
+        onChange: (formData: any) => Promise<void>;
+    };
+    onChange: (formData: any) => Promise<void>;
+    private fetchTaxaFromSet;
+}