expensify-common 2.0.188 → 2.0.190

package/dist/esm/Templates.js

@@ -0,0 +1,196 @@
+import $ from 'jquery';
+import createTemplate from 'lodash/template';
+import * as Utils from './utils';
+/**
+ * JS Templating system, powered by underscore template
+ *
+ * Templates is a global namespace for each template, HTML ones or inlines ones.
+ *
+ * @type Module
+ * @class
+ */
+const templateStore = {};
+/**
+ * @param {String} templateValue
+ * @returns {{get: function(Object=): String}}
+ */
+function createInlineTemplate(templateValue) {
+    let compiled = null;
+    let storedValue = templateValue;
+    return {
+        get(data = {}) {
+            if (!compiled) {
+                compiled = createTemplate(storedValue, {
+                    imports: {
+                        // Here we ignore the eslint rule because _ is imported from OD which does not exist in this repo
+                        // eslint-disable-next-line no-undef, object-shorthand
+                        _: _,
+                    },
+                });
+                storedValue = '';
+            }
+            return compiled(data);
+        },
+    };
+}
+/**
+ * @param {String} id
+ * @param {function} getNestedTemplate
+ * @returns {{get: function(Object=): String}}
+ */
+function createDOMTemplate(id, getNestedTemplate) {
+    let compiled = null;
+    return {
+        get(data = {}) {
+            // Add the "template" object to the parameter to allow nested templates
+            const dataToCompile = Object.assign({}, data);
+            dataToCompile.nestedTemplate = getNestedTemplate;
+            if (!compiled) {
+                compiled = createTemplate($(`#${id}`).html(), {
+                    imports: {
+                        // Here we ignore the eslint rule because _ is imported from OD which does not exist in this repo
+                        // eslint-disable-next-line no-undef, object-shorthand
+                        _: _,
+                    },
+                });
+            }
+            return compiled(dataToCompile);
+        },
+    };
+}
+/**
+ * Returns the template
+ *
+ * @param {Array} templatePath
+ * @returns {InlineTemplate|undefined}
+ */
+function getTemplate(templatePath) {
+    let template = templateStore;
+    for (const pathname of templatePath) {
+        template = template[pathname];
+    }
+    return template;
+}
+/**
+ * Based on an array of string, return a reference to the object that should hold the template
+ * used to augment the template object
+ *
+ * @param {Array} wantedNamespace Array of string reprensenting the namespace
+ * @returns {Object} Referene to the object holding the namespace
+ */
+function getTemplateNamespace(wantedNamespace) {
+    let namespace = templateStore;
+    let currentArgument;
+    for (let argumentNumber = 0; argumentNumber < wantedNamespace.length; argumentNumber++) {
+        currentArgument = wantedNamespace[argumentNumber];
+        if (namespace[currentArgument] === undefined) {
+            namespace[currentArgument] = {};
+        }
+        namespace = namespace[currentArgument];
+    }
+    return namespace;
+}
+const Templates = {
+    /**
+     * Given a templatePath, return the value
+     *
+     * @param {Array} templatePath
+     * @param {Object} [data] Information that need to be injected into the template
+     * @returns {String}
+     */
+    get(templatePath, data = {}) {
+        const template = getTemplate(templatePath);
+        if (template === undefined) {
+            throw Error(`Template '${templatePath}' is not defined`);
+        }
+        // Check for the absense of get which means someone is likely using
+        // the templating engine wrong and trying to access a template namespace
+        if (!{}.propertyIsEnumerable.call(template, 'get')) {
+            throw Error(`'${templatePath}' is not a valid template path`);
+        }
+        return template.get(data);
+    },
+    /**
+     * Given a templatePath, does it have a registered template?
+     * @param  {Array} templatePath
+     * @returns {Boolean}
+     */
+    has(templatePath) {
+        return getTemplate(templatePath) !== undefined;
+    },
+    /**
+     * Inits the templating engine, and slurps all DOM templates in an internal data structure
+     */
+    init() {
+        // Read the DOM to find all the templates, and make them available to the code
+        for (const $el of $('.js_template').toArray()) {
+            const namespaceElements = $el.id.split('_');
+            const id = namespaceElements.pop();
+            // remove the prefix "template" that MUST be added to have clean HTML ids
+            namespaceElements.shift();
+            const namespace = getTemplateNamespace(namespaceElements);
+            namespace[id] = createDOMTemplate($el.id, Templates.get);
+        }
+    },
+    /**
+     * Register a new json object in the template manager
+     *
+     * @param {Array} wantedNamespace Namespace where we want to store the templates
+     * @param {object} templateData The literal object that contain the templates
+     */
+    register(wantedNamespace, templateData) {
+        const namespace = getTemplateNamespace(wantedNamespace);
+        for (const key of Object.keys(templateData)) {
+            const template = templateData[key];
+            if (Utils.isObject(template)) {
+                // If the template is an object, add templates for all keys
+                namespace[key] = {};
+                for (const templateKey of Object.keys(template)) {
+                    namespace[key][templateKey] = createInlineTemplate(template[templateKey]);
+                }
+            }
+            else {
+                namespace[key] = createInlineTemplate(template);
+            }
+        }
+    },
+    /**
+     * Removes a namespace from the templateStore (only used for testing purposes)
+     *
+     * @param {String} nameSpace
+     */
+    unregister(nameSpace) {
+        delete templateStore[nameSpace];
+    },
+    /**
+     * Replace the DOM HTML with the template value
+     *
+     * @param {jQuery} $target Element(s) that will be updated
+     * @param {Array} templatePath
+     * @param {Object} [data] Information that need to be injected into the template
+     */
+    insert($target, templatePath, data = {}) {
+        $target.html(this.get(templatePath, data));
+    },
+    /**
+     * Append the template value into a DOM elements
+     *
+     * @param {jQuery} $target Element(s) that will be updated
+     * @param {Array} templatePath
+     * @param {Object} data Information that need to be injected into the template
+     */
+    prepend($target, templatePath, data) {
+        $target.prepend(this.get(templatePath, data));
+    },
+    /**
+     * Prepend the template value into a DOM elements
+     *
+     * @param {jQuery} $target Element(s) that will be updated
+     * @param {array} templatePath
+     * @param {object} [data] Information that need to be injected into the template
+     */
+    append($target, templatePath, data) {
+        $target.append(this.get(templatePath, data));
+    },
+};
+export default Templates;

package/dist/esm/Url.d.ts

@@ -0,0 +1,10 @@
+export const URL_WEBSITE_REGEX: string;
+export const URL_PATH_REGEX: string;
+export const URL_PARAM_REGEX: string;
+export const URL_FRAGMENT_REGEX: string;
+export const URL_REGEX: string;
+export const URL_REGEX_WITH_REQUIRED_PROTOCOL: string;
+export const URL_PROTOCOL_REGEX: "((ht|f)tps?:\\/\\/)";
+export const LOOSE_URL_REGEX: string;
+export const LOOSE_URL_WEBSITE_REGEX: "((ht|f)tps?:\\/\\/)((?!-)[-a-z0-9]+(?<!-)(?:\\.(?!-)[-a-z0-9]+(?<!-))*)(?:\\:([1-9][0-9]{0,3}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5])|\\b|(?=_))";
+export const MARKDOWN_URL_REGEX: string;

package/dist/esm/Url.js

@@ -0,0 +1,15 @@
+import TLD_REGEX from './tlds';
+const ALLOWED_PORTS = '([1-9][0-9]{0,3}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5])';
+const URL_PROTOCOL_REGEX = '((ht|f)tps?:\\/\\/)';
+const URL_WEBSITE_REGEX = `${URL_PROTOCOL_REGEX}?((?:www\\.)?[a-z0-9](?=(?<label>[-a-z0-9]*[a-z0-9])?)\\k<label>\\.)+(?:${TLD_REGEX})\
+(?:\\:${ALLOWED_PORTS}|\\b|(?=_))(?!@(?:[a-z\\d-]+\\.)+[a-z]{2,})`;
+const addEscapedChar = (reg) => `(?:${reg}|&(?:amp|#x27);)`;
+const URL_PATH_REGEX = `(?:${addEscapedChar('[.,=(+$!*]')}?\\/${addEscapedChar('[-\\w$@.+!*:(),=%~]')}*${addEscapedChar('[-\\w~@:%)]')}|\\/)*`;
+const URL_PARAM_REGEX = `(?:\\?${addEscapedChar('[-\\w$@.+!*()\\/,=%{}:;\\[\\]\\|_|~]')}+)?`;
+const URL_FRAGMENT_REGEX = `(?:#${addEscapedChar('[-\\w$@.+!*()[\\],=%;\\/:~]')}*)?`;
+const URL_REGEX = `((${URL_WEBSITE_REGEX})${URL_PATH_REGEX}(?:${URL_PARAM_REGEX}|${URL_FRAGMENT_REGEX})*)`;
+const URL_REGEX_WITH_REQUIRED_PROTOCOL = URL_REGEX.replace(`${URL_PROTOCOL_REGEX}?`, URL_PROTOCOL_REGEX);
+const LOOSE_URL_WEBSITE_REGEX = `${URL_PROTOCOL_REGEX}((?!-)[-a-z0-9]+(?<!-)(?:\\.(?!-)[-a-z0-9]+(?<!-))*)(?:\\:${ALLOWED_PORTS}|\\b|(?=_))`;
+const LOOSE_URL_REGEX = `((${LOOSE_URL_WEBSITE_REGEX})${URL_PATH_REGEX}(?:${URL_PARAM_REGEX}|${URL_FRAGMENT_REGEX})*)`;
+const MARKDOWN_URL_REGEX = `(${LOOSE_URL_REGEX}|${URL_REGEX})`;
+export { URL_WEBSITE_REGEX, URL_PATH_REGEX, URL_PARAM_REGEX, URL_FRAGMENT_REGEX, URL_REGEX, URL_REGEX_WITH_REQUIRED_PROTOCOL, URL_PROTOCOL_REGEX, LOOSE_URL_REGEX, LOOSE_URL_WEBSITE_REGEX, MARKDOWN_URL_REGEX, };

package/dist/esm/components/CopyText.d.ts

@@ -0,0 +1,45 @@
+export default CopyText;
+/**
+ * Simple render prop component that encapsulates the Clipboard feature and exposes a function that can be tied to any event
+ *
+ * @example
+ *
+ * <React.c.CopyText textContent="I am some text" onSuccess={() => {}}>
+ *    {copy => (
+ *        <React.c.Button onClick={copy}>
+ *            Copy Me!
+ *        </React.c.Button>
+ *     )}
+ * </React.c.CopyText>
+ */
+declare class CopyText extends React.Component<any, any, any> {
+    constructor(props: any);
+    constructor(props: any, context: any);
+    componentDidMount(): void;
+    hiddenLink: HTMLAnchorElement | undefined;
+    clipboard: Clipboard | undefined;
+    componentWillUnmount(): void;
+    /**
+     * Fires click event on invisible link
+     */
+    copyTextToClipboard(): void;
+    render(): any;
+}
+declare namespace CopyText {
+    export { propTypes };
+    export { defaultProps };
+}
+import React from 'react';
+import Clipboard from 'clipboard';
+declare namespace propTypes {
+    let onSuccess: PropTypes.Requireable<(...args: any[]) => any>;
+    let textContent: PropTypes.Requireable<string>;
+    let children: PropTypes.Validator<(...args: any[]) => any>;
+}
+declare namespace defaultProps {
+    export function onSuccess_1(): void;
+    export { onSuccess_1 as onSuccess };
+    let textContent_1: string;
+    export { textContent_1 as textContent };
+}
+import PropTypes from 'prop-types';

package/dist/esm/components/CopyText.js

@@ -0,0 +1,56 @@
+import React from 'react';
+import Clipboard from 'clipboard';
+import PropTypes from 'prop-types';
+const propTypes = {
+    // Callback fired when text has been copied - useful to display UI confirmation
+    onSuccess: PropTypes.func,
+    // The text to be copied
+    textContent: PropTypes.string,
+    // Function as a child exposes the copyTextToClipboard fuction
+    children: PropTypes.func.isRequired,
+};
+const defaultProps = {
+    onSuccess: () => { },
+    textContent: '',
+};
+/**
+ * Simple render prop component that encapsulates the Clipboard feature and exposes a function that can be tied to any event
+ *
+ * @example
+ *
+ * <React.c.CopyText textContent="I am some text" onSuccess={() => {}}>
+ *    {copy => (
+ *        <React.c.Button onClick={copy}>
+ *            Copy Me!
+ *        </React.c.Button>
+ *     )}
+ * </React.c.CopyText>
+ */
+class CopyText extends React.Component {
+    componentDidMount() {
+        this.hiddenLink = document.createElement('a');
+        // Sets up the clipboard instance
+        this.clipboard = new Clipboard(this.hiddenLink, {
+            text: () => this.props.textContent,
+        });
+        // Fires callback when the clipboard has succesfully copied
+        this.clipboard.on('success', () => {
+            this.props.onSuccess();
+        });
+    }
+    componentWillUnmount() {
+        this.clipboard.destroy();
+    }
+    /**
+     * Fires click event on invisible link
+     */
+    copyTextToClipboard() {
+        this.hiddenLink.click();
+    }
+    render() {
+        return this.props.children(() => this.copyTextToClipboard());
+    }
+}
+CopyText.propTypes = propTypes;
+CopyText.defaultProps = defaultProps;
+export default CopyText;

package/dist/esm/components/StepProgressBar.d.ts

@@ -0,0 +1,26 @@
+export default StepProgressBar;
+/**
+ * Step progress bar.
+ *
+ * @param {object} props Component props
+ * @param {array} props.steps Array of {id, title}
+ * @param {string} props.currentStep Current step id
+ *
+ * @returns {React.Component}
+ */
+declare function StepProgressBar({ steps, currentStep }: {
+    steps: array;
+    currentStep: string;
+}): React.Component;
+declare namespace StepProgressBar {
+    export { propTypes };
+}
+import React from 'react';
+declare namespace propTypes {
+    let steps: PropTypes.Validator<(PropTypes.InferProps<{
+        id: PropTypes.Validator<string>;
+        title: PropTypes.Validator<string>;
+    }> | null | undefined)[]>;
+    let currentStep: PropTypes.Validator<string>;
+}
+import PropTypes from 'prop-types';

package/dist/esm/components/StepProgressBar.js

@@ -0,0 +1,40 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import cn from 'classnames';
+import * as UIConstants from '../CONST';
+const stepShape = {
+    id: PropTypes.string.isRequired,
+    title: PropTypes.string.isRequired,
+};
+const propTypes = {
+    steps: PropTypes.arrayOf(PropTypes.shape(stepShape)).isRequired,
+    currentStep: PropTypes.string.isRequired,
+};
+/**
+ * Step progress bar.
+ *
+ * @param {object} props Component props
+ * @param {array} props.steps Array of {id, title}
+ * @param {string} props.currentStep Current step id
+ *
+ * @returns {React.Component}
+ */
+function StepProgressBar({ steps, currentStep }) {
+    const isCurrentStep = (step) => step.id === currentStep;
+    const currentStepIndex = Math.max(0, steps.findIndex(isCurrentStep));
+    const renderStep = (step, i) => {
+        let status = currentStepIndex === i ? UIConstants.UI.ACTIVE : '';
+        if (currentStepIndex > i) {
+            status = 'complete';
+        }
+        return (React.createElement("div", { key: step.id, className: cn('progress-step', 'js_step', step.id, status) },
+            React.createElement("div", { className: "progress-dot" },
+                React.createElement("div", { className: "inner" })),
+            React.createElement("div", { className: "progress-desc" },
+                React.createElement("span", { className: "js_step_title" }, step.title))));
+    };
+    return (React.createElement("div", { id: "js_steps_progress", className: "progress-wrapper" },
+        React.createElement("div", { className: "progress" }, steps.map(renderStep))));
+}
+StepProgressBar.propTypes = propTypes;
+export default StepProgressBar;

package/dist/esm/components/form/element/combobox.d.ts

@@ -0,0 +1,231 @@
+export default Combobox;
+/**
+ * A combobox useful for searching for values in a large list
+ */
+declare class Combobox extends React.Component<any, any, any> {
+    constructor(props: any);
+    /**
+     * @param {Boolean} noDefaultValue Overrides the default value to have '' as the currentValue
+     * @param {Object[]} [newOptions] when resetting this component, we can specify new options to use
+     * @param {Object[]} [newAlreadySelectedOptions] when resetting this component, we can specify new already selected options to use
+     *
+     * @returns {Object}
+     */
+    getStartState(noDefaultValue: boolean, newOptions?: Object[], newAlreadySelectedOptions?: Object[]): Object;
+    /**
+     * Returns a set of our full options according to the maxItemsToShow
+     *
+     * @param {String|Number} currentValue
+     * @param {Object[]} [newAlreadySelectedOptions]
+     * @returns {Array}
+     */
+    getTruncatedOptions(currentValue: string | number, newAlreadySelectedOptions?: Object[]): any[];
+    /**
+     * Returns the selected value(s)
+     *
+     * @returns {String}
+     */
+    getValue(): string;
+    /**
+     * Sets the current value
+     *
+     * @param {String} val
+     */
+    setValue(val: string): void;
+    /**
+     * Hard sets the current text to what we want
+     *
+     * @param {String} val
+     */
+    setText(val: string): void;
+    /**
+     * Sets the disabled state of this component
+     *
+     * @param {Boolean} isDisabled
+     */
+    setDisabled(isDisabled: boolean): void;
+    /**
+     * Set an error for a specific tag
+     */
+    setError(): void;
+    /**
+     * Deselects any current option if it exists
+     */
+    deselectCurrentOption(): void;
+    /**
+     * Swaps the focused index from {oldFocusedIndex} to {newFocusedIndex}
+     *
+     * @param {number} oldFocusedIndex
+     * @param {number} newFocusedIndex
+     */
+    switchFocusedIndex(oldFocusedIndex: number, newFocusedIndex: number): void;
+    /**
+     * Returns the selector to it's original state
+     *
+     * @param {Boolean} noDefaultValue Overrides the initials state defaultValue by setting the currentValue to ''
+     * @param {Object[]} [newOptions] we can recreate it with new options
+     * @param {Object[]} [newAlreadySelectedOptions] we can recreate it with new already selected options
+     */
+    reset(noDefaultValue: boolean, newOptions?: Object[], newAlreadySelectedOptions?: Object[]): void;
+    /**
+     * When the dropdown is closed, we reset the focused property of all of our options
+     */
+    resetFocusedElements(): void;
+    /**
+     * Fired when we "click away" with the dropdown open
+     *
+     * @param {SyntheticEvent} e
+     */
+    handleClickAway(e: SyntheticEvent): void;
+    /**
+     * Sets a clicklistener to close the dropdown if it is currently open
+     */
+    resetClickAwayHandler(): void;
+    /**
+     * Clear an error for a specific tag
+     */
+    clearError(): void;
+    /**
+     * Opens or closes the dropdown
+     */
+    toggleDropdown(): void;
+    /**
+     * Just open the dropdown (when the input gets focus)
+     */
+    openDropdown(): void;
+    /**
+     * Closes the dropdown and removes the click handler that calls this function after the dropdown is closed
+     *
+     * @param {SyntheticEvent} [e]
+     */
+    closeDropdown(e?: SyntheticEvent): void;
+    /**
+     * If the user presses tab when the dropdown button is focused, then we close the dropdown
+     * because they are trying to get to the next form components
+     *
+     * @param {SyntheticEvent} e
+     */
+    closeDropdownOnTabOut(e: SyntheticEvent): void;
+    /**
+     * This is triggered whenever there is a key up event in the text input
+     *
+     * @param {SyntheticEvent} e
+     */
+    handleKeyDown(e: SyntheticEvent): void;
+    /**
+     * This is triggered whenever there is a change event in the text input
+     * (from any valid input that's not being handled from the keyUp event)
+     *
+     * @param {SyntheticEvent} e
+     */
+    performSearch(e: SyntheticEvent): void;
+    /**
+     * Handle state changes for when a user clicks on an item in the dropdown
+     *
+     * @param  {String|Number} selectedValue
+     */
+    handleClick(selectedValue: string | number): void;
+    state: Object;
+    scrollPosition: number;
+    componentDidMount(): void;
+    UNSAFE_componentWillReceiveProps(nextProps: any): void;
+    componentDidUpdate(): void;
+    componentWillUnmount(): void;
+    initialValue: any;
+    options: any;
+    initialText: any;
+    render(): React.JSX.Element | null;
+    value: HTMLInputElement | null | undefined;
+    dropDown: DropDown | null | undefined;
+}
+declare namespace Combobox {
+    export { propTypes };
+    export { defaultProps };
+}
+import React from 'react';
+import DropDown from './dropdown';
+declare namespace propTypes {
+    let options: PropTypes.Validator<(PropTypes.InferProps<{
+        value: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
+        text: PropTypes.Requireable<string>;
+        children: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        hasError: PropTypes.Requireable<boolean>;
+        disabled: PropTypes.Requireable<boolean>;
+        id: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
+        divider: PropTypes.Requireable<boolean>;
+        selected: PropTypes.Requireable<boolean>;
+    }> | null | undefined)[]>;
+    let defaultValue: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
+    let value: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
+    let alreadySelectedOptions: PropTypes.Requireable<(PropTypes.InferProps<{
+        id: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
+        value: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
+        text: PropTypes.Requireable<string>;
+    }> | null | undefined)[]>;
+    let onChange: PropTypes.Requireable<(...args: any[]) => any>;
+    let onClear: PropTypes.Requireable<(...args: any[]) => any>;
+    let onDropdownStateChange: PropTypes.Requireable<(...args: any[]) => any>;
+    let maxItemsToShow: PropTypes.Requireable<number>;
+    let maxSearchResults: PropTypes.Requireable<number>;
+    let propertyToDisplay: PropTypes.Requireable<string>;
+    let openOnInit: PropTypes.Requireable<boolean>;
+    let allowAnyValue: PropTypes.Requireable<boolean>;
+    let noResultsText: PropTypes.Requireable<string>;
+    let isReadOnly: PropTypes.Requireable<boolean>;
+    let placeholder: PropTypes.Requireable<string>;
+    let extraClasses: PropTypes.Requireable<NonNullable<string | object | null | undefined>>;
+    let hideUntilManuallyOpened: PropTypes.Requireable<boolean>;
+    let alwaysShowSelectedOnTop: PropTypes.Requireable<boolean>;
+    let hasInitialError: PropTypes.Requireable<boolean>;
+    let bs4: PropTypes.Requireable<boolean>;
+    let showDisabledOptionsInResults: PropTypes.Requireable<boolean>;
+    let autoScrollToTop: PropTypes.Requireable<boolean>;
+    let dropDownClasses: PropTypes.Requireable<NonNullable<string | object | null | undefined>>;
+}
+declare namespace defaultProps {
+    let defaultValue_1: string;
+    export { defaultValue_1 as defaultValue };
+    let value_1: string;
+    export { value_1 as value };
+    export function onChange_1(): void;
+    export { onChange_1 as onChange };
+    export function onClear_1(): void;
+    export { onClear_1 as onClear };
+    export function onDropdownStateChange_1(): void;
+    export { onDropdownStateChange_1 as onDropdownStateChange };
+    let maxItemsToShow_1: number;
+    export { maxItemsToShow_1 as maxItemsToShow };
+    let maxSearchResults_1: number;
+    export { maxSearchResults_1 as maxSearchResults };
+    let propertyToDisplay_1: string;
+    export { propertyToDisplay_1 as propertyToDisplay };
+    let allowAnyValue_1: boolean;
+    export { allowAnyValue_1 as allowAnyValue };
+    let openOnInit_1: boolean;
+    export { openOnInit_1 as openOnInit };
+    let isReadOnly_1: boolean;
+    export { isReadOnly_1 as isReadOnly };
+    let alreadySelectedOptions_1: never[];
+    export { alreadySelectedOptions_1 as alreadySelectedOptions };
+    let noResultsText_1: string;
+    export { noResultsText_1 as noResultsText };
+    let placeholder_1: string;
+    export { placeholder_1 as placeholder };
+    let extraClasses_1: never[];
+    export { extraClasses_1 as extraClasses };
+    let hideUntilManuallyOpened_1: boolean;
+    export { hideUntilManuallyOpened_1 as hideUntilManuallyOpened };
+    let alwaysShowSelectedOnTop_1: boolean;
+    export { alwaysShowSelectedOnTop_1 as alwaysShowSelectedOnTop };
+    let hasInitialError_1: boolean;
+    export { hasInitialError_1 as hasInitialError };
+    let bs4_1: boolean;
+    export { bs4_1 as bs4 };
+    let showDisabledOptionsInResults_1: boolean;
+    export { showDisabledOptionsInResults_1 as showDisabledOptionsInResults };
+    let autoScrollToTop_1: boolean;
+    export { autoScrollToTop_1 as autoScrollToTop };
+    let dropDownClasses_1: never[];
+    export { dropDownClasses_1 as dropDownClasses };
+}
+import PropTypes from 'prop-types';