cozy-ui 128.2.0 → 128.3.1

package/transpiled/react/Contacts/AddModal/ContactForm/helpers.js

@@ -0,0 +1,335 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+var _excluded = ["postcode"];
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import get from 'lodash/get';
+import isEqual from 'lodash/isEqual';
+import merge from 'lodash/merge';
+import uniqueId from 'lodash/uniqueId';
+import { Association } from 'cozy-client';
+import { makeDisplayName } from 'cozy-client/dist/models/contact';
+import { CONTACTS_DOCTYPE } from 'cozy-client/dist/models/contact';
+import contactToFormValues from "cozy-ui/transpiled/react/Contacts/AddModal/ContactForm/contactToFormValues";
+export var fieldsRequired = ['givenName', 'familyName', 'email[0].email', 'cozy'];
+/**
+ * Returns errors if all required fields are empty
+ * @param {object} values - Fields values
+ * @param {func} t - Translation function
+ * @returns {object} Errors
+ */
+
+export var validateFields = function validateFields(values, t) {
+  var errors = {};
+
+  if (fieldsRequired.every(function (field) {
+    return !get(values, field);
+  })) {
+    fieldsRequired.forEach(function (field) {
+      errors[field] = t('Contacts.AddModal.ContactForm.fields.required');
+    });
+  }
+
+  return errors;
+};
+/**
+ * @param {object} [item] - Contact attribute
+ * @returns {string} Stringified object
+ */
+
+export var makeItemLabel = function makeItemLabel(item) {
+  if (!item) return undefined;
+  var res = item.label || item.type ? JSON.stringify({
+    type: item.type,
+    label: item.label
+  }) : undefined;
+  return res;
+};
+/**
+ *
+ * @param {string} [itemLabel] - Value of the label for a contact attribute
+ * @returns {{ type?: string, label?: string }}
+ */
+
+export var makeTypeAndLabel = function makeTypeAndLabel(itemLabel) {
+  if (!itemLabel) {
+    return {
+      type: undefined,
+      label: undefined
+    };
+  }
+
+  var itemLabelObj = JSON.parse(itemLabel);
+  var res = {
+    type: itemLabelObj.type,
+    label: itemLabelObj.label
+  };
+  return res;
+};
+/**
+ * @param {object} addressField
+ * @returns {boolean} True if addressField has extended address
+ */
+
+export var hasExtendedAddress = function hasExtendedAddress(addressField) {
+  if (!addressField) return false;
+  var extendedAddressKeys = ['addresslocality', 'addressbuilding', 'addressstairs', 'addressfloor', 'addressapartment', 'addressentrycode'];
+  return Object.keys(addressField).some(function (ext) {
+    return extendedAddressKeys.includes(ext);
+  });
+};
+export var moveToHead = function moveToHead(shouldBeHead) {
+  return function (items) {
+    return items.reduce(function (arr, v) {
+      return shouldBeHead(v) ? [v].concat(_toConsumableArray(arr)) : [].concat(_toConsumableArray(arr), [v]);
+    }, []);
+  };
+};
+export var movePrimaryToHead = moveToHead(function (v) {
+  return v === null || v === void 0 ? void 0 : v.primary;
+});
+export var createAddress = function createAddress(_ref) {
+  var address = _ref.address,
+      oldContact = _ref.oldContact,
+      t = _ref.t;
+  return address ? address.filter(function (val) {
+    return val && val.address;
+  }).map(function (addressField, index) {
+    var _oldContact$address, _contactToFormValues, _contactToFormValues$;
+
+    var oldContactAddress = oldContact === null || oldContact === void 0 ? void 0 : (_oldContact$address = oldContact.address) === null || _oldContact$address === void 0 ? void 0 : _oldContact$address[index];
+    var oldContactFormValues = (_contactToFormValues = contactToFormValues(oldContact, t)) === null || _contactToFormValues === void 0 ? void 0 : (_contactToFormValues$ = _contactToFormValues.address) === null || _contactToFormValues$ === void 0 ? void 0 : _contactToFormValues$[index];
+    var addressHasBeenModified = !isEqual(addressField, oldContactFormValues);
+
+    if (addressHasBeenModified) {
+      // Use "code" instead "postcode", to be vcard 4.0 rfc 6350 compliant
+      // eslint-disable-next-line no-unused-vars
+      var _ref2 = oldContactAddress || {},
+          postcode = _ref2.postcode,
+          oldContactAddressCleaned = _objectWithoutProperties(_ref2, _excluded);
+
+      return _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, oldContactAddressCleaned), {}, {
+        formattedAddress: addressField.address,
+        number: addressField.addressnumber,
+        street: addressField.addressstreet,
+        code: addressField.addresscode,
+        city: addressField.addresscity,
+        region: addressField.addressregion,
+        country: addressField.addresscountry
+      }, hasExtendedAddress(addressField) && {
+        extendedAddress: _objectSpread(_objectSpread({}, oldContactAddressCleaned.extendedAddress), {}, {
+          locality: addressField.addresslocality,
+          building: addressField.addressbuilding,
+          stairs: addressField.addressstairs,
+          floor: addressField.addressfloor,
+          apartment: addressField.addressapartment,
+          entrycode: addressField.addressentrycode
+        })
+      }), makeTypeAndLabel(addressField.addressLabel)), {}, {
+        primary: index === 0
+      });
+    }
+
+    return oldContactAddress;
+  }) : [];
+};
+/**
+ * @param {(import('../../../types').RelatedContact|undefined)[]} relatedContact - The related contacts array
+ * @returns {Record<string, { data: { _id: string, _type: string }[] }>} - The related contacts relationships
+ */
+
+export var getRelatedContactRelationships = function getRelatedContactRelationships(relatedContact) {
+  // Tips filter Boolean to remove undefined value from array when relatedContact is empty (see contactToFormValues)
+  var data = relatedContact.filter(Boolean).reduce(function (acc, curr) {
+    var relationType = curr.relatedContactLabel ? JSON.parse(curr.relatedContactLabel).type : 'related';
+    var existingIndex = acc.findIndex(function (item) {
+      return item._id === curr.relatedContactId;
+    });
+
+    if (existingIndex !== -1) {
+      acc[existingIndex].metadata.relationTypes = Array.from(new Set([].concat(_toConsumableArray(acc[existingIndex].metadata.relationTypes), [relationType])));
+    } else {
+      acc.push({
+        _id: curr.relatedContactId,
+        _type: CONTACTS_DOCTYPE,
+        metadata: {
+          relationTypes: [relationType]
+        }
+      });
+    }
+
+    return acc;
+  }, []); // `data` can be empty, you still have to return an object to override the behavior of the cozy-client store, otherwise it will keep the old value, and without refreshing the page, the data will not be up to date in the store and therefore on the interface
+
+  return {
+    related: {
+      data: data
+    }
+  };
+};
+/**
+ * When changing the type of relationship, it must be ensured that no empty relationship remains.
+ * The old and new ones are merged into `formValuesToContact`.
+ *
+ * @param {import('cozy-client/types/types').IOCozyContact} contact - The contact object with all relationships
+ * @returns {import('cozy-client/types/types').IOCozyContact} - The contact object without the related contacts relationships
+ */
+
+export var removeRelatedContactRelationships = function removeRelatedContactRelationships(contact) {
+  if (!(contact !== null && contact !== void 0 && contact.relationships)) return contact;
+  var updatedContact = merge({}, contact);
+  var relationshipsWithoutRelatedContact = Object.entries(updatedContact.relationships).reduce(function (acc, _ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2),
+        relName = _ref4[0],
+        relValue = _ref4[1];
+
+    if ('related' === relName) {
+      acc[relName] = relValue;
+    }
+
+    return acc;
+  }, {});
+  updatedContact.relationships = relationshipsWithoutRelatedContact;
+  return updatedContact;
+}; // TODO : Update dehydrate function to HasMany class in cozy-client
+
+/**
+ * This function is used to clean the contact object from the associated data
+ * cozy-client dehydrates the document before saving it (via the `HasMany` method), but by doing it manually, we ensure that all hydrated relationships in the document (and without data of course) are not saved in the `relationships` of the document, which adds unnecessary data.
+ *
+ * @param {import('cozy-client/types/types').IOCozyContact} contact - The contact object with associated data
+ * @returns {import('cozy-client/types/types').IOCozyContact} - The contact object without associated data
+ */
+
+export var removeAsscociatedData = function removeAsscociatedData(contact) {
+  if (!contact) return {};
+  return Object.entries(contact).reduce(function (cleanedContact, _ref5) {
+    var _ref6 = _slicedToArray(_ref5, 2),
+        key = _ref6[0],
+        value = _ref6[1];
+
+    // Add `groups` condition to keep the old implementation functional, see below
+    if (!(value instanceof Association) || key === 'groups') {
+      cleanedContact[key] = value;
+    }
+
+    return cleanedContact;
+  }, {});
+};
+/**
+ * @param {import('cozy-client/types/types').IOCozyContact} contact
+ * @returns {import('../../../types').RelatedContact[]}
+ */
+
+export var makeRelatedContact = function makeRelatedContact(contact) {
+  var _contact$relationship;
+
+  if (!(contact.related instanceof Association) || !((_contact$relationship = contact.relationships) !== null && _contact$relationship !== void 0 && _contact$relationship.related)) {
+    return [undefined];
+  }
+
+  var relatedData = contact.related.data.reduce(function (acc, curr) {
+    // Use `makeDisplayName` because if the contact is newly created, it has no `displayName` attribute. (Creation of a contact when selecting a linked contact)
+    acc[curr._id] = curr.displayName || makeDisplayName(curr);
+    return acc;
+  }, {});
+  var res = contact.relationships.related.data.flatMap(function (item) {
+    return item.metadata.relationTypes.map(function (type) {
+      return {
+        relatedContactId: item._id,
+        relatedContact: relatedData[item._id],
+        relatedContactLabel: makeItemLabel({
+          type: type === 'related' ? '' : type
+        })
+      };
+    });
+  }); // Useful because a contact always has at least the `related` relationships (see `getRelatedContactRelationships`)
+
+  return res.length > 0 ? res : [undefined];
+};
+export var addField = function addField(fields) {
+  return fields.push({
+    fieldId: uniqueId('fieldId_')
+  });
+};
+export var removeField = function removeField(fields, index) {
+  var isLastRemainingField = fields.length === 1;
+
+  if (isLastRemainingField) {
+    fields.update(index, undefined);
+  } else {
+    fields.remove(index);
+  }
+};
+/**
+ *
+ * @param {string} value
+ * @param {func} t
+ * @returns {string}
+ */
+
+export var makeCustomLabel = function makeCustomLabel(value, t) {
+  var _JSON$parse = JSON.parse(value),
+      type = _JSON$parse.type,
+      label = _JSON$parse.label;
+
+  var firstString = type || '';
+  var secondString = label ? type ? " (".concat(t("Contacts.AddModal.ContactForm.label.".concat(label)), ")").toLowerCase() : "label.".concat(label) : '';
+  return firstString + secondString || null;
+};
+/**
+ *
+ * @param {string} name
+ * @param {string} value
+ * @returns {string}
+ */
+
+export var makeInitialCustomValue = function makeInitialCustomValue(name, value) {
+  // gender input doesn't support custom label
+  if (!name || !value || name === 'gender') return undefined;
+  var valueObj = JSON.parse(value); // Voluntarily before the "backwards compatibility" condition
+
+  if (name.includes('relatedContactLabel')) {
+    if (!'related' === valueObj.type) {
+      return JSON.stringify({
+        type: valueObj.type
+      });
+    }
+
+    return undefined;
+  } // for backwards compatiblity - historically there is only type and no label
+
+
+  if (valueObj.type && !valueObj.label) {
+    return JSON.stringify({
+      type: valueObj.type
+    });
+  } // for phone label
+
+
+  if (name.includes('phoneLabel')) {
+    // but unsupported one
+    if (!['cell', 'voice', 'fax'].includes(valueObj.type)) {
+      return JSON.stringify({
+        type: valueObj.type,
+        label: valueObj.label
+      });
+    } // we don't want to create a custom label if supported
+
+
+    return undefined;
+  } // at this point if label and type are both present, it's a custom label
+
+
+  if (valueObj.type && valueObj.label) {
+    return JSON.stringify({
+      type: valueObj.type,
+      label: valueObj.label
+    });
+  }
+};

package/transpiled/react/Contacts/AddModal/ContactForm/helpers.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/transpiled/react/Contacts/AddModal/ContactForm/index.d.ts

@@ -0,0 +1,11 @@
+export function getSubmitContactForm(): any;
+export function isSameContactProp(prevProps: any, nextProps: any): boolean;
+declare var _default: React.MemoExoticComponent<({ contact, onSubmit, contacts }: {
+    contact: import('cozy-client/types/types').IOCozyContact;
+    onSubmit: func;
+    contacts: {
+        data: Array<object>;
+    };
+}) => JSX.Element>;
+export default _default;
+import React from "react";

package/transpiled/react/Contacts/AddModal/ContactForm/index.js

@@ -0,0 +1,114 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import arrayMutators from 'final-form-arrays';
+import React from 'react';
+import { Form } from 'react-final-form';
+import { getHasManyItems } from 'cozy-client/dist/associations/HasMany';
+import FieldInputLayout from "cozy-ui/transpiled/react/Contacts/AddModal/ContactForm/FieldInputLayout";
+import contactToFormValues from "cozy-ui/transpiled/react/Contacts/AddModal/ContactForm/contactToFormValues";
+import { fields } from "cozy-ui/transpiled/react/Contacts/AddModal/ContactForm/fieldsConfig";
+import formValuesToContact from "cozy-ui/transpiled/react/Contacts/AddModal/ContactForm/formValuesToContact";
+import { validateFields } from "cozy-ui/transpiled/react/Contacts/AddModal/ContactForm/helpers";
+import { locales } from "cozy-ui/transpiled/react/Contacts/AddModal/ContactForm/locales";
+import { useI18n, useExtendI18n } from "cozy-ui/transpiled/react/providers/I18n"; // import { fullContactPropTypes } from '../../ContactPropTypes' // !!
+// this variable will be set in the form's render prop
+// and used by the submit button in ContactFormModal
+// to be able to trigger the submit from outside the form
+// See react-final-form examples here: https://www.npmjs.com/package/react-final-form#external-submit
+
+var _submitContactForm;
+
+function setSubmitContactForm(handleSubmit) {
+  _submitContactForm = handleSubmit;
+}
+
+export function getSubmitContactForm() {
+  return _submitContactForm;
+}
+/**
+ *
+ * @param {object} params
+ * @param {import('cozy-client/types/types').IOCozyContact} params.contact
+ * @param {func} params.onSubmit
+ * @param {{ data: Array<object> }} params.contacts
+ * @returns
+ */
+
+var ContactForm = function ContactForm(_ref) {
+  var contact = _ref.contact,
+      _onSubmit = _ref.onSubmit,
+      contacts = _ref.contacts;
+  useExtendI18n(locales);
+
+  var _useI18n = useI18n(),
+      t = _useI18n.t;
+
+  return /*#__PURE__*/React.createElement(Form, {
+    mutators: _objectSpread({}, arrayMutators),
+    validate: function validate(values) {
+      return validateFields(values, t);
+    },
+    onSubmit: function onSubmit(formValues) {
+      return _onSubmit(formValuesToContact({
+        formValues: formValues,
+        oldContact: contact,
+        t: t
+      }));
+    },
+    initialValues: contactToFormValues(contact, t),
+    render: function render(_ref2) {
+      var handleSubmit = _ref2.handleSubmit,
+          valid = _ref2.valid,
+          submitFailed = _ref2.submitFailed,
+          errors = _ref2.errors;
+      setSubmitContactForm(handleSubmit);
+      return /*#__PURE__*/React.createElement("form", {
+        role: "form",
+        onSubmit: handleSubmit,
+        className: "u-flex u-flex-column"
+      }, fields.map(function (attributes, index) {
+        return /*#__PURE__*/React.createElement(FieldInputLayout, {
+          key: index,
+          attributes: attributes,
+          contacts: contacts,
+          formProps: {
+            valid: valid,
+            submitFailed: submitFailed,
+            errors: errors
+          }
+        });
+      }));
+    }
+  });
+}; // Used to avoid unnecessary multiple rendering of ContactForm when creating a new contact in another way.
+// These unnecessary renderings prevented the addition of a newly created linked contact. (Creation of a contact when selecting a linked contact)
+
+
+export var isSameContactProp = function isSameContactProp(prevProps, nextProps) {
+  var _prevProps$contact, _nextProps$contact;
+
+  if (!((_prevProps$contact = prevProps.contact) !== null && _prevProps$contact !== void 0 && _prevProps$contact.relationships) || !((_nextProps$contact = nextProps.contact) !== null && _nextProps$contact !== void 0 && _nextProps$contact.relationships)) {
+    return false;
+  }
+
+  var prevContactIdsRelated = getHasManyItems(prevProps.contact, 'related').map(function (r) {
+    return r._id;
+  });
+  var nextContactIdsRelated = getHasManyItems(nextProps.contact, 'related').map(function (r) {
+    return r._id;
+  });
+
+  if (prevContactIdsRelated.length !== nextContactIdsRelated.length || !prevContactIdsRelated.every(function (id) {
+    return nextContactIdsRelated.includes(id);
+  })) {
+    return false;
+  }
+
+  return true;
+}; // export default ContactForm
+
+export default /*#__PURE__*/React.memo(ContactForm, isSameContactProp);

package/transpiled/react/Contacts/AddModal/ContactForm/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/transpiled/react/Contacts/AddModal/ContactForm/locales/index.d.ts

@@ -0,0 +1,6 @@
+export namespace locales {
+    export { en };
+    export { fr };
+}
+import en from "./en.json";
+import fr from "./fr.json";

package/transpiled/react/Contacts/AddModal/ContactForm/locales/index.js

@@ -0,0 +1,150 @@
+var en = {
+  Contacts: {
+    AddModal: {
+      ContactForm: {
+        gender: {
+          man: "Man",
+          woman: "Woman"
+        },
+        fields: {
+          gender: "Civility",
+          givenName: "Firstname",
+          additionalName: "2nd firstname",
+          surname: "Name in use",
+          familyName: "Lastname",
+          phone: "Phone",
+          email: "Email",
+          address: "Address",
+          cozy: "Twake URL",
+          company: "Company",
+          jobTitle: "Job title",
+          birthday: "Birthday",
+          birthplace: "Birthplace",
+          relatedContact: "Related contact",
+          relationship: "Relationship",
+          note: "Notes",
+          label: "Label",
+          required: "One of these fields must be filled in"
+        },
+        label: {
+          none: "None",
+          home: "Personal",
+          work: "Pro",
+          custom: "Customised",
+          phone: {
+            "cell-home": "Cell (personal)",
+            "cell-work": "Cell (pro)",
+            "voice-home": "Voice (personal)",
+            "voice-work": "Voice (pro)",
+            "fax-home": "Fax (personal)",
+            "fax-work": "Fax (pro)"
+          },
+          address: {
+            home: "Home (personal)",
+            work: "Work (pro)"
+          },
+          relationship: {
+            parent: "Parent",
+            child: "Child",
+            sibling: "Sibling",
+            spouse: "Spouse",
+            coResident: "Co-resident",
+            friend: "Friend",
+            colleague: "Colleague",
+            coWorker: "Co-worker",
+            acquaintance: "Acquaintance",
+            helper: "Helper",
+            recipient: "Recipient"
+          }
+        },
+        addLabel: {
+          address: "Add an address",
+          email: "Add an email",
+          phone: "Add a phone",
+          relatedContact: "Add a related contact"
+        }
+      }
+    }
+  },
+  formatted: {
+    date: "yyyy-LL-dd",
+    address: "%{number} %{street}, %{code} %{city}, %{country}"
+  }
+};
+var fr = {
+  Contacts: {
+    AddModal: {
+      ContactForm: {
+        gender: {
+          man: "Homme",
+          woman: "Femme"
+        },
+        fields: {
+          gender: "Civilit\xE9",
+          givenName: "Pr\xE9nom",
+          additionalName: "2e pr\xE9nom",
+          surname: "Nom d'usage",
+          familyName: "Nom",
+          phone: "T\xE9l\xE9phone",
+          email: "Email",
+          address: "Adresse",
+          cozy: "URL du Twake",
+          company: "Entreprise",
+          jobTitle: "Fonction",
+          birthday: "Anniversaire",
+          birthplace: "Lieu de naissance",
+          relatedContact: "Contact li\xE9",
+          relationship: "Relation",
+          note: "Notes",
+          label: "Libell\xE9",
+          required: "Un de ces champs doit \xEAtre renseign\xE9"
+        },
+        label: {
+          none: "Aucun",
+          home: "Perso",
+          work: "Pro",
+          custom: "Personnalis\xE9",
+          phone: {
+            "cell-home": "Mobile (perso)",
+            "cell-work": "Mobile (pro)",
+            "voice-home": "Fixe (perso)",
+            "voice-work": "Fixe (pro)",
+            "fax-home": "Fax (perso)",
+            "fax-work": "Fax (pro)"
+          },
+          address: {
+            home: "Domicile (perso)",
+            work: "Travail (pro)"
+          },
+          relationship: {
+            parent: "Parent",
+            child: "Enfant",
+            sibling: "Fr\xE8re/Soeur",
+            spouse: "Conjoint",
+            coResident: "Colocataire",
+            friend: "Ami",
+            colleague: "Coll\xE8gue/Collaborateur",
+            coWorker: "Associ\xE9/Partenaire",
+            acquaintance: "Connaissance",
+            helper: "Assistant/Aidant",
+            recipient: "B\xE9n\xE9ficiaire/Aid\xE9"
+          }
+        },
+        addLabel: {
+          address: "Ajouter une adresse",
+          email: "Ajouter un email",
+          phone: "Ajouter un t\xE9l\xE9phone",
+          relatedContact: "Ajouter un contact li\xE9"
+        }
+      }
+    }
+  },
+  formatted: {
+    date: "dd/LL/yyyy",
+    address: "%{number} %{street}, %{code} %{city}, %{country}"
+  }
+};
+export var locales = {
+  en: en,
+  fr: fr
+};

package/transpiled/react/Contacts/AddModal/CustomLabelDialog/index.d.ts

@@ -0,0 +1,22 @@
+export default CustomLabelDialog;
+declare function CustomLabelDialog({ customValue, setCustomValue, customLabelOptions, onSubmit, onClose }: {
+    customValue: any;
+    setCustomValue: any;
+    customLabelOptions: any;
+    onSubmit: any;
+    onClose: any;
+}): JSX.Element;
+declare namespace CustomLabelDialog {
+    namespace propTypes {
+        const customValue: PropTypes.Requireable<string>;
+        const setCustomValue: PropTypes.Requireable<(...args: any[]) => any>;
+        const customLabelOptions: PropTypes.Requireable<PropTypes.InferProps<{
+            hide: PropTypes.Requireable<boolean>;
+            defaultType: PropTypes.Requireable<string>;
+            defaultLabel: PropTypes.Requireable<string>;
+        }>>;
+        const onSubmit: PropTypes.Requireable<(...args: any[]) => any>;
+        const onClose: PropTypes.Requireable<(...args: any[]) => any>;
+    }
+}
+import PropTypes from "prop-types";