@formio/js 5.0.0-dev.5610.da13e39 → 5.0.0-dev.5613.3476921

package/lib/mjs/components/_classes/component/Component.d.ts

@@ -6,34 +6,36 @@ declare class Component extends Element {
     static schema(...sources: any[]): any;
     /**
      * Return the simple condition settings as part of the component.
-     * @returns {object} - The simple conditional settings.
+     *
+     * @return {Object}
+     *
      */
-    static get conditionOperatorsSettings(): object;
+    static get conditionOperatorsSettings(): Object;
     /**
      * Return the array of possible types of component value absed on its schema.
+     *
      * @param schema
-     * @returns {Array}
+     * @return {Array}
+     *
      */
     static savedValueTypes(schema: any): any[];
     /**
      * Provides a table view for this component. Override if you wish to do something different than using getView
      * method of your instance.
+     *
      * @param value
      * @param options
      */
     static tableView(value: any, options: any): void;
-    /**
-     * Returns the component condition operator settings if available.
-     * @returns {object} - The component condition operator settings.
-     */
-    static get serverConditionSettings(): object;
+    static get serverConditionSettings(): Object;
     /**
      * Initialize a new Component.
-     * @param {object} component - The component JSON you wish to initialize.
-     * @param {object} options - The options for this component.
-     * @param {object} data - The global data submission object this component will belong.
+     *
+     * @param {Object} component - The component JSON you wish to initialize.
+     * @param {Object} options - The options for this component.
+     * @param {Object} data - The global data submission object this component will belong.
      */
-    constructor(component: object, options: object, data: object);
+    constructor(component: Object, options: Object, data: Object);
     id: any;
     /**
      * Determines if this component has a condition assigned to it.
@@ -47,6 +49,7 @@ declare class Component extends Element {
     refs: {};
     /**
      * The data path to this specific component instance.
+     *
      * @type {string}
      */
     path: string;
@@ -90,27 +93,32 @@ declare class Component extends Element {
     row: number;
     /**
      * Points to a flat map of child components (if applicable).
-     * @type {object}
+     *
+     * @type {Object}
      */
-    childComponentsMap: object;
+    childComponentsMap: Object;
     /**
      * Determines if this component is disabled, or not.
+     *
      * @type {boolean}
      */
     _disabled: boolean;
     /**
      * Points to the root component, usually the FormComponent.
+     *
      * @type {Component}
      */
     root: Component;
     localRoot: any;
     /**
      * If this input has been input and provided value.
+     *
      * @type {boolean}
      */
     pristine: boolean;
     /**
      * Points to the parent component.
+     *
      * @type {Component}
      */
     parent: Component;
@@ -128,6 +136,7 @@ declare class Component extends Element {
     triggerChange: (...args: any[]) => any;
     /**
      * Used to trigger a redraw event within this component.
+     *
      * @type {Function}
      */
     triggerRedraw: Function;
@@ -145,12 +154,13 @@ declare class Component extends Element {
     type: any;
     /**
      * Sets the static value of this component.
-     * @param {*} value - The value to set for this component.
+     *
+     * @param value
      */
     set dataValue(value: any);
     /**
      * Get the static value of this component.
-     * @returns {*} - The value for this component.
+     * @return {*}
      */
     get dataValue(): any;
     /**
@@ -174,12 +184,13 @@ declare class Component extends Element {
     init(): void;
     /**
      * Disable this component.
-     * @param {boolean} disabled - TRUE to disable the component.
+     *
+     * @param {boolean} disabled
      */
     set disabled(disabled: boolean);
     /**
      * Return if the component is disabled.
-     * @returns {boolean} - TRUE if the component is disabled.
+     * @return {boolean}
      */
     get disabled(): boolean;
     afterComponentAssign(): void;
@@ -198,13 +209,13 @@ declare class Component extends Element {
     shouldForceHide(component: any): any;
     shouldForceShow(component: any): any;
     /**
-     * Sets the component visibility.
-     * @param {boolean} value - Whether the component should be visible or not.
+     *
+     * @param value {boolean}
      */
     set visible(value: boolean);
     /**
-     * Returns the component visibility
-     * @returns {boolean} - Whether the component is visible or not.
+     *
+     * @returns {boolean}
      */
     get visible(): boolean;
     set currentForm(instance: any);
@@ -228,30 +239,26 @@ declare class Component extends Element {
     };
     /**
      * Returns only the schema that is different from the default.
-     * @param {object} schema - The "full" json schema for the component.
-     * @param {object} defaultSchema - The "default" json schema for the component.
-     * @param {boolean} recursion - If we are currently in a recursive loop.
-     * @returns {object} - The minified json schema for this component.
+     *
+     * @param schema
+     * @param defaultSchema
      */
-    getModifiedSchema(schema: object, defaultSchema: object, recursion: boolean): object;
+    getModifiedSchema(schema: any, defaultSchema: any, recursion: any): any;
     /**
      * Returns the JSON schema for this component.
-     * @returns {object} - The JSON schema for this component.
      */
-    get schema(): object;
+    get schema(): any;
     /**
      * Returns true if component is inside DataGrid
-     * @returns {boolean} - True if component is inside DataGrid
      */
-    get isInDataGrid(): boolean;
+    get isInDataGrid(): any;
     /**
      * Translate a text using the i18n system.
+     *
      * @param {string} text - The i18n identifier.
-     * @param {object} params - The i18n parameters to use for translation.
-     * @param {...any} args - Additional arguments to pass to the translation library.
-     * @returns {string} - The translated text.
+     * @param {Object} params - The i18n parameters to use for translation.
      */
-    t(text: string, params?: object, ...args: any[]): string;
+    t(text: string, params?: Object, ...args: any[]): any;
     labelIsHidden(): any;
     transform(type: any, value: any): any;
     getTemplate(names: any, modes: any): {
@@ -265,72 +272,53 @@ declare class Component extends Element {
         referenceAttributeName: any;
     } | null;
     checkTemplateMode(templatesByName: any, modes: any): any;
-    getFormattedAttribute(attr: any): string;
-    getFormattedTooltip(tooltipValue: any): string;
+    getFormattedAttribute(attr: any): any;
+    getFormattedTooltip(tooltipValue: any): any;
     isHtmlRenderMode(): boolean;
-    renderTemplate(name: any, data?: {}, modeOption?: string): any;
+    renderTemplate(name: any, data: {} | undefined, modeOption: any): any;
     /**
      * Sanitize an html string.
-     * @param {string} dirty - The dirty html string to sanitize.
-     * @param {boolean} forceSanitize - If we should force the sanitize to occur.
-     * @param {object} options - The options for the sanitize.
-     * @returns {*} - The sanitized html string.
+     *
+     * @param string
+     * @returns {*}
      */
-    sanitize(dirty: string, forceSanitize?: boolean, options?: object): any;
+    sanitize(dirty: any, forceSanitize: any, options: any): any;
     /**
      * Render a template string into html.
-     * @param {string} template - The template to render.
-     * @param {object} data - The data to provide to the template.
-     * @returns {HTMLElement | string} - The created element or an empty string if template is not specified.
-     */
-    renderString(template: string, data: object): HTMLElement | string;
-    /**
-     * Allows for modification of the component value prior to submission.
-     * @param {*} input - The input to be modified.
-     * @returns {*} - The modified input mapping for the extended component.
+     *
+     * @param template
+     * @param data
+     * @param actions
+     *
+     * @return {HTMLElement|String} - The created element or an empty string if template is not specified.
      */
+    renderString(template: any, data: any): HTMLElement | string;
     performInputMapping(input: any): any;
-    /**
-     * Returns the component "widget" if one is available.
-     * @returns {Widget|null} - The widget instance. null if not available.
-     */
     get widget(): any;
+    getBrowserLanguage(): any;
     /**
-     * Returns the native supported browser language.
-     * @returns {string|null} - The native browser language that is supported.
-     */
-    getBrowserLanguage(): string | null;
-    /**
-     * Called before a next and previous page is triggered allowing the components to perform special functions.
-     * @returns {Promise<boolean>} - A promise to resolve when the component is no longer blocking the next/previous page navigation.
-     */
-    beforePage(): Promise<boolean>;
-    /**
-     * Called before the next page is triggered allowing the components to hook into the page navigation and perform tasks.
-     * @returns {Promise<boolean>} - A promise to resolve when the component is no longer blocking the next page navigation.
+     * Called before a next and previous page is triggered allowing the components
+     * to perform special functions.
+     *
+     * @return {*}
      */
-    beforeNext(): Promise<boolean>;
+    beforePage(): any;
+    beforeNext(): any;
     /**
-     * Called before a submission is triggered allowing the components to perform special async functions.
-     * @returns {Promise<boolean>} - A promise to resolve when the component is no longer blocking the submission.
+     * Called before a submission is triggered allowing the components
+     * to perform special async functions.
+     *
+     * @return {*}
      */
-    beforeSubmit(): Promise<boolean>;
+    beforeSubmit(): any;
     /**
      * Return the submission timezone.
-     * @returns {string} - The submission timezone.
-     */
-    get submissionTimezone(): string;
-    /**
-     * Return the current timezone.
-     * @returns {string} - The current timezone.
-     */
-    get timezone(): string;
-    /**
-     * Return the current timezone.
-     * @param {object} settings - Settings to control how the timezone should be returned.
-     * @returns {string} - The current timezone.
+     *
+     * @return {*}
      */
-    getTimezone(settings: object): string;
+    get submissionTimezone(): any;
+    get timezone(): any;
+    getTimezone(settings: any): any;
     /**
      *
      * @param {HTMLElement} element - The containing DOM element to query for the ref value.
@@ -338,92 +326,28 @@ declare class Component extends Element {
      * @param {string} [referenceAttributeName] - The attribute name to use for the reference.
      */
     loadRefs(element: HTMLElement, refs: object, referenceAttributeName?: string | undefined): void;
-    /**
-     * Opens the modal element.
-     * @param {string} template - The template to use for the modal dialog.
-     */
-    setOpenModalElement(template?: string): void;
-    /**
-     * Returns the modal preview template.
-     * @returns {string} - The modal preview template.
-     */
-    getModalPreviewTemplate(): string;
-    /**
-     * Performs a complete build of a component, which empties, renders, sets the content in the DOM, and then finally attaches events.
-     * @param {HTMLElement} element - The element to attach this component to.
-     * @returns {Promise<void>} - A promise that resolves when the component has been built.
-     */
-    build(element: HTMLElement): Promise<void>;
+    setOpenModalElement(template: any): void;
+    getModalPreviewTemplate(): any;
+    build(element: any): Promise<void>;
     get hasModalSaveButton(): boolean;
-    /**
-     * Renders a component as an HTML string.
-     * @param {string} children - The contents of all the children HTML as a string.
-     * @param {boolean} topLevel - If this is the topmost component that is being rendered.
-     * @returns {string} - The rendered HTML string of a component.
-     */
-    render(children?: string, topLevel?: boolean): string;
-    /**
-     * Attaches all the tooltips provided the refs object.
-     * @param {object} toolTipsRefs - The refs for the tooltips within your template.
-     * @returns {void}
-     */
-    attachTooltips(toolTipsRefs: object): void;
-    /**
-     * Create a new component modal for this component.
-     * @param {HTMLElement} element - The element to attach the modal to.
-     * @param {boolean} modalShouldBeOpened - TRUE if the modal should open immediately.
-     * @param {any} currentValue - The current value of the component.
-     * @returns {ComponentModal} - The created component modal.
-     */
-    createComponentModal(element: HTMLElement, modalShouldBeOpened: boolean, currentValue: any): ComponentModal;
-    /**
-     * Attaches all event listensers for this component to the DOM elements that were rendered.
-     * @param {HTMLElement} element - The element to attach the listeners to.
-     * @returns {Promise<void>} - Resolves when the component is done attaching to the DOM.
-     */
-    attach(element: HTMLElement): Promise<void>;
+    render(children?: string, topLevel?: boolean): any;
+    attachTooltips(toolTipsRefs: any): void;
+    createComponentModal(element: any, modalShouldBeOpened: any, currentValue: any): ComponentModal;
+    attach(element: any): Promise<void>;
     componentModal: any;
-    /**
-     * Restors the "focus" on a component after a redraw event has occured.
-     */
     restoreFocus(): void;
-    /**
-     * Adds a keyboard shortcut to this component.
-     * @param {HTMLElement} element - The element to attach the keyboard shortcut to.
-     * @param {string} shortcut - The keyboard shortcut to add.
-     * @returns {void}
-     */
-    addShortcut(element: HTMLElement, shortcut: string): void;
-    /**
-     * Removes a keyboard shortcut from this component.
-     * @param {HTMLElement} element - The element to remove the keyboard shortcut from.
-     * @param {string} shortcut - The keyboard shortcut to remove.
-     * @returns {void}
-     */
-    removeShortcut(element: HTMLElement, shortcut: string): void;
+    addShortcut(element: any, shortcut: any): void;
+    removeShortcut(element: any, shortcut: any): void;
     /**
      * Remove all event handlers.
      */
     detach(): void;
-    /**
-     * Determines if the component should be refreshed based on the path of another component that changed.
-     * @param {string} refreshData - The path of the data that needs to trigger a refresh.
-     * @param {boolean} changed - Flag that is true if the data has been changed.
-     * @param {any} flags - The flags for the checkData procedure.
-     * @returns {void}
-     */
-    checkRefresh(refreshData: string, changed: boolean, flags: any): void;
-    /**
-     * Iterates over a list of changes, and determines if the component should be refreshed if it is configured to refresh on any of those components.
-     * @param {Array<any>} changes - The list of components that have changed.
-     * @param {any} flags - The checkData flags.
-     * @returns {void}
-     */
-    checkRefreshOn(changes: Array<any>, flags?: any): void;
+    checkRefresh(refreshData: any, changed: any, flags: any): void;
+    checkRefreshOn(changes: any, flags?: {}): void;
     /**
      * Refreshes the component with a new value.
-     * @param {any} value - The latest value of the component to check if it needs to be refreshed.
-     * @returns {void}
+     *
+     * @param value
      */
     refresh(value: any): void;
     refreshOnChanged: boolean | undefined;
@@ -434,84 +358,33 @@ declare class Component extends Element {
      * with the components data and returns true if they are in the same context.
      *
      * Different rows of the same EditGrid, for example, are in different contexts.
-     * @param {any} component - The component to check if it is in the same context as this component.
-     * @returns {boolean} - TRUE if the component is in the same context as this component.
+     *
+     * @param component
      */
     inContext(component: any): boolean;
-    /**
-     * Determines if we are in "view" only mode.
-     * @returns {boolean} - TRUE if we are in "view" only mode.
-     */
-    get viewOnly(): boolean;
-    /**
-     * Sets the HTMLElement for this component.
-     * @param {HTMLElement} element - The element that is attached to this component.
-     * @returns {void}
-     */
-    setElement(element: HTMLElement): void;
+    get viewOnly(): any;
+    setElement(element: any): void;
     element: any;
-    /**
-     * Creates an element to hold the "view only" version of this component.
-     * @returns {HTMLElement} - The element for this component.
-     */
-    createViewOnlyElement(): HTMLElement;
-    /**
-     * The default value for the "view only" mode of a component if the value is not provided.
-     * @returns {string} - The default value for this component.
-     */
+    createViewOnlyElement(): any;
     get defaultViewOnlyValue(): string;
     /**
      * Uses the widget to determine the output string.
-     * @param {any} value - The current value of the component.
-     * @param {any} options - The options for getValueAsString.
-     * @returns {any|Array<any>} - The value as a string.
-     */
-    getWidgetValueAsString(value: any, options: any): any | Array<any>;
-    /**
-     * Returns the value of the component as a string.
-     * @param {any} value - The value for this component.
-     * @param {any} options - The options for this component.
-     * @returns {string} - The string representation of the value of this component.
-     */
-    getValueAsString(value: any, options: any): string;
-    /**
-     * Returns the string representation "view" of the component value.
-     * @param {any} value - The value of the component.
-     * @param {any} options - The options for this component.
-     * @returns {string} - The string representation of the value of this component.
-     */
-    getView(value: any, options: any): string;
-    /**
-     * Updates the items list for this component. Useful for Select and other List component types.
-     * @param {...any} args - The arguments to pass to the onChange event.
-     * @returns {void}
+     *
+     * @param value
+     * @return {*}
      */
+    getWidgetValueAsString(value: any, options: any): any;
+    getValueAsString(value: any, options: any): any;
+    getView(value: any, options: any): any;
     updateItems(...args: any[]): void;
     /**
-     * Returns the value for a specific item in a List type component.
-     * @param {any} data - The data for this component.
-     * @param {boolean} [forceUseValue] - if true, return 'value' property of the data
-     * @returns {any} - The value of the item.
+     * @param {*} data
+     * @param {boolean} [forceUseValue=false] - if true, return 'value' property of the data
+     * @return {*}
      */
     itemValue(data: any, forceUseValue?: boolean | undefined): any;
-    /**
-     * Returns the item value for html mode.
-     * @param {any} value - The value for this component.
-     * @returns {any} - The value of the item for html mode.
-     */
     itemValueForHTMLMode(value: any): any;
-    /**
-     * Creates a modal to input the value of this component.
-     * @param {HTMLElement} element - The element to attach the modal to.
-     * @param {any} attr - A list of attributes to add to the modal.
-     * @param {boolean} confirm - If we should add a confirmation to the modal that keeps it from closing unless confirmed.
-     * @returns {HTMLElement} - The created modal element.
-     */
-    createModal(element: HTMLElement, attr: any, confirm: boolean): HTMLElement;
-    /**
-     * Uses CSS classes to show or hide an element.
-     * @returns {boolean} - TRUE if the element has been css removed.
-     */
+    createModal(element: any, attr: any, confirm: any): HTMLElement;
     get optimizeRedraw(): boolean;
     /**
      * Retrieves the CSS class name of this component.
@@ -520,251 +393,125 @@ declare class Component extends Element {
     get className(): string;
     /**
      * Build the custom style from the layout values
-     * @returns {string} - The custom style
+     * @return {string} - The custom style
      */
     get customStyle(): string;
-    /**
-     * Returns if the application is on a mobile device.
-     * @returns {boolean} - TRUE if the application is on a mobile device.
-     */
-    get isMobile(): boolean;
+    get isMobile(): import("ismobilejs").isMobileResult;
     /**
      * Returns the outside wrapping element of this component.
-     * @returns {HTMLElement} - The wrapping element of this component.
+     * @returns {HTMLElement}
      */
     getElement(): HTMLElement;
-    /**
-     * Create an evaluation context for all script executions and interpolations.
-     * @param {any} additional - Additional context to provide.
-     * @returns {any} - The evaluation context.
-     */
-    evalContext(additional: any): any;
     /**
      * Sets the pristine flag for this component.
-     * @param {boolean} pristine - TRUE to make pristine, FALSE not pristine.
+     *
+     * @param pristine {boolean} - TRUE to make pristine, FALSE not pristine.
      */
     setPristine(pristine: boolean): void;
-    /**
-     * Returns if the component is pristine.
-     * @returns {boolean} - TRUE if the component is pristine.
-     */
     get isPristine(): boolean;
-    /**
-     * Sets the dirty flag for this component.
-     * @param {boolean} dirty - TRUE to make dirty, FALSE not dirty.
-     */
-    setDirty(dirty: boolean): void;
-    dirty: boolean | undefined;
-    /**
-     * Returns if the component is dirty.
-     * @returns {boolean} - TRUE if the component is dirty.
-     */
-    get isDirty(): boolean;
+    setDirty(dirty: any): void;
+    dirty: any;
+    get isDirty(): any;
     /**
      * Removes a value out of the data array and rebuild the rows.
      * @param {number} index - The index of the data element to remove.
      */
     removeValue(index: number): void;
-    /**
-     * Returns the icon class for a given icon name.
-     * @param {string} name - The name of the icon you wish to fetch provided the icon class. This is the "font awesome" version of the name of the icon.
-     * @param {boolean} spinning - If the component should be spinning.
-     * @returns {string} - The icon class for the equivalent icon in the iconset we are using.
-     */
-    iconClass(name: string, spinning: boolean): string;
-    /**
-     * Returns the size css class names for our current template.
-     * @param {string} size - The size class name for the default iconset.
-     * @returns {string} - The size class for our component.
-     */
-    size(size: string): string;
+    iconClass(name: any, spinning: any): any;
+    size(size: any): any;
     /**
      * The readible name for this component.
      * @returns {string} - The name of the component.
      */
     get name(): string;
-    /**
-     * Returns the visible errors for this component.
-     * @returns {Array<object>} - The visible errors for this component.
-     */
-    get visibleErrors(): object[];
-    /**
-     * Returns all the errors for this component, visible or not.
-     * @returns {Array<object>} - All the errors for this component.
-     */
-    get errors(): object[];
+    get visibleErrors(): any[];
+    get errors(): any[];
     /**
      * Returns the error label for this component.
-     * @returns {string} - The error label for this component.
+     * @return {*}
      */
-    get errorLabel(): string;
+    get errorLabel(): any;
     /**
      * Get the error message provided a certain type of error.
-     * @param {string} type - The type of error to fetch the message for.
-     * @returns {string} - The error message configured for this component.
-     */
-    errorMessage(type: string): string;
-    /**
-     * Sets the content, innerHTML, of an element to the sanitized content.
-     * @param {HTMLElement} element - The element to set the innerHTML to.
-     * @param {string} content - The HTML string content that we wish to set.
-     * @param {boolean} forceSanitize - If we should force the content to be sanitized.
-     * @param {any} sanitizeOptions - The options for the sanitize function.
-     * @returns {boolean} - TRUE if the content was sanitized and set.
-     */
-    setContent(element: HTMLElement, content: string, forceSanitize: boolean, sanitizeOptions: any): boolean;
-    /**
-     * Restores the caret position in the input element after a refresh occurs.
+     * @param type
+     * @return {*}
      */
+    errorMessage(type: any): any;
+    setContent(element: any, content: any, forceSanitize: any, sanitizeOptions: any): boolean;
     restoreCaretPosition(): void;
-    /**
-     * Redraw the component.
-     * @returns {Promise<void>} - A promise that resolves when the component is done redrawing.
-     */
     redraw(): Promise<void>;
-    /**
-     * Rebuild and redraw a component.
-     * @returns {Promise<void>} - A promise that resolves when the component is done rebuilding and redrawing.
-     */
     rebuild(): Promise<void>;
-    /**
-     * Returns if the dom node has the classes provided.
-     * @param {HTMLElement} element - The element to check for the class.
-     * @param {string} className - The name of the class to check.
-     * @returns {boolean|void} - TRUE if the element has the class.
-     */
-    hasClass(element: HTMLElement, className: string): boolean | void;
-    /**
-     * Adds a class to an HTML element.
-     * @param {HTMLElement} element - The dom element to add the class to.
-     * @param {string} className - The class name you wish to add.
-     * @returns {this|void} - The component instance.
-     */
-    addClass(element: HTMLElement, className: string): this | void;
-    /**
-     * Removes a class from an element.
-     * @param {HTMLElement} element - The element to remove the class from.
-     * @param {string} className - The class name to remove.
-     * @returns {this|void} - The component instance.
-     */
-    removeClass(element: HTMLElement, className: string): this | void;
+    hasClass(element: any, className: any): boolean | undefined;
+    addClass(element: any, className: any): this | undefined;
+    removeClass(element: any, className: any): this | undefined;
     /**
      * Determines if this component has a condition defined.
-     * @returns {boolean} - TRUE if the component has a condition defined.
+     *
+     * @return {null}
      */
-    hasCondition(): boolean;
+    hasCondition(): null;
     /**
      * Check if this component is conditionally visible.
-     * @param {any} data - The data to check against.
-     * @param {any} row - The row data to check against.
-     * @returns {boolean} - TRUE if the component is conditionally visible.
+     *
+     * @param data
+     * @return {boolean}
      */
     conditionallyVisible(data: any, row: any): boolean;
     /**
      * Checks the condition of this component.
      *
      * TODO: Switch row and data parameters to be consistent with other methods.
-     * @param {any} row - The row contextual data.
-     * @param {any} data - The global data object.
-     * @returns {boolean} - True if the condition applies to this component.
+     *
+     * @param row - The row contextual data.
+     * @param data - The global data object.
+     * @return {boolean} - True if the condition applies to this component.
      */
     checkCondition(row: any, data: any): boolean;
     /**
      * Check for conditionals and hide/show the element based on those conditions.
-     * @param {any} data - The data to check against.
-     * @param {any} flags - The flags passed to checkData function.
-     * @param {any} row - The row data to check against.
-     * @returns {boolean} - TRUE if the component is visible.
      */
     checkComponentConditions(data: any, flags: any, row: any): boolean;
     /**
      * Checks conditions for this component and any sub components.
-     * @param {any} data - The data to check against.
-     * @param {any} flags - The flags passed to checkData function.
-     * @param {any} row - The row data to check against.
-     * @returns {boolean} - TRUE if the component is visible.
+     * @param args
+     * @return {boolean}
      */
     checkConditions(data: any, flags: any, row: any): boolean;
-    /**
-     * Returns the component logic if applicable.
-     * @returns {Array<object>} - The component logic.
-     */
-    get logic(): object[];
+    get logic(): any;
     /**
      * Check all triggers and apply necessary actions.
-     * @param {any} data - The data to check against.
-     * @param {any} row - The row data to check against.
-     * @returns {boolean|void} - TRUE if the component was altered.
-     */
-    fieldLogic(data?: any, row?: any): boolean | void;
-    /**
-     * Retuns if the browser is Internet Explorer.
-     * @returns {boolean} - TRUE if the browser is IE.
-     */
-    isIE(): boolean;
-    /**
-     * Defines the logic action value through evaluation.
-     * @param {object} action - The action within the Logic system to perform.
-     * @param {object} argsObject - The arguments to pass to the evaluation.
-     * @returns {any} - The result of the evaluation.
-     */
-    defineActionValue(action: object, argsObject: object): any;
-    /**
-     * Apply the actions of Logic for a component once the conditions have been met.
-     * @param {object} newComponent - The new component to apply the actions to.
-     * @param {Array<object>} actions - An array of actions
-     * @param {any} result - The result of the conditional check in order to evaluate the actions.
-     * @param {any} row - The contextual row data for this component.
-     * @param {any} data - The global data object for the submission.
-     * @returns {boolean} - TRUE if the component was altered.
+     *
+     * @param data
      */
-    applyActions(newComponent: object, actions: Array<object>, result: any, row: any, data: any): boolean;
+    fieldLogic(data: any, row: any): any;
+    isIE(): number | false;
+    defineActionValue(action: any, argsObject: any): any;
+    applyActions(newComponent: any, actions: any, result: any, row: any, data: any): any;
     addInputError(message: any, dirty: any, elements: any): void;
     removeInputError(elements: any): void;
     /**
      * Add a new input error to this element.
-     * @param {Array<object>|string} messages - An array of messages to add to the element.
-     * @returns {void}
-     */
-    addMessages(messages: Array<object> | string): void;
-    /**
-     * Sets the form input widget error classes.
-     * @param {Array<HTMLElement>} elements - An array of DOM elements to set the error classes on.
-     * @param {boolean} dirty - If the input is dirty.
-     * @param {boolean} hasErrors - If the input has errors.
-     * @param {boolean} hasMessages - If the input has messages.
-     * @param {HTMLElement} element - The wrapper element for all the other elements passed in first argument.
-     * @returns {void}
-     */
-    setErrorClasses(elements: Array<HTMLElement>, dirty: boolean, hasErrors: boolean, hasMessages: boolean, element?: HTMLElement): void;
-    /**
-     * Adds the classes necessary to mark an element as invalid.
-     * @param {HTMLElement} element - The element you wish to add the invalid classes to.
-     * @param {boolean} invalid - TRUE if the component is invalid, FALSE otherwise.
-     * @returns {void}
-     */
-    setElementInvalid(element: HTMLElement, invalid: boolean): void;
-    /**
-     * Clears the components data if it is conditionally hidden AND clearOnHide is set to true for this component.
-     */
+     *
+     * @param {{level: string, message: string}[]} messages
+     */
+    addMessages(messages: {
+        level: string;
+        message: string;
+    }[]): void;
+    setErrorClasses(elements: any, dirty: any, hasErrors: any, hasMessages: any, element?: any): void;
+    setElementInvalid(element: any, invalid: any): void;
     clearOnHide(): void;
-    /**
-     * Triggers a debounced onChange event for the root component (usually Webform).
-     * @param {...any} args - The arguments to pass to the onChange event.
-     */
     triggerRootChange(...args: any[]): void;
-    /**
-     * Called when the component value has been changed. This will then trigger the root level onChange handler which
-     * propagates the checkData methods for the full component tree.
-     * @param {any} flags - The flags for the change event propagation.
-     * @param {boolean} fromRoot - If the change event is from the root component.
-     * @returns {boolean} - TRUE if the component has changed.
-     */
-    onChange(flags: any, fromRoot: boolean): boolean;
+    onChange(flags: any, fromRoot: any): {
+        instance: this;
+        component: any;
+        value: any;
+        flags: any;
+    };
     get wysiwygDefault(): {
         quill: {
             theme: string;
-            placeholder: string;
+            placeholder: any;
             modules: {
                 toolbar: ({
                     size: (string | boolean)[];
@@ -801,7 +548,7 @@ declare class Component extends Element {
             minLines: number;
             tabSize: number;
             mode: string;
-            placeholder: string;
+            placeholder: any;
         };
         ckeditor: {
             image: {
@@ -820,27 +567,28 @@ declare class Component extends Element {
     get tree(): any;
     /**
      * The empty value for this component.
-     * @returns {null} - The empty value for this component.
+     *
+     * @return {null}
      */
     get emptyValue(): null;
     /**
      * Returns if this component has a value set.
-     * @param {any} data - The global data object.
-     * @returns {boolean} - TRUE if a value is set.
+     *
      */
     hasValue(data: any): boolean;
     /**
      * Get the data value at the root level.
-     * @returns {*} - The root value for the component, typically the Webform data object.
+     *
+     * @return {*}
      */
     get rootValue(): any;
     get rootPristine(): any;
     /**
      * Splice a value from the dataValue.
-     * @param {number} index - The index to splice for an array component values.
-     * @param {*} flags - The flags to use when splicing the value.
+     *
+     * @param index
      */
-    splice(index: number, flags?: any): void;
+    splice(index: any, flags?: {}): void;
     unset(): void;
     /**
      * Deletes the value of the component.
@@ -851,29 +599,33 @@ declare class Component extends Element {
     get defaultValue(): any;
     /**
      * Get the input value of this component.
-     * @returns {*} - The value for the component.
+     *
+     * @return {*}
      */
     getValue(): any;
     /**
      * Get the value at a specific index.
-     * @param {number} index - For an array component or multiple values, this returns the value at a specific index.
-     * @returns {*} - The value at the specified index.
+     *
+     * @param index
+     * @returns {*}
      */
-    getValueAt(index: number): any;
+    getValueAt(index: any): any;
     /**
      * Set the value of this component.
-     * @param {*} value - The value to set for this component.
-     * @param {*} flags - The flags to use when setting the value.
-     * @returns {boolean} - If the value changed.
+     *
+     * @param value
+     * @param flags
+     *
+     * @return {boolean} - If the value changed.
      */
-    setValue(value: any, flags?: any): boolean;
+    setValue(value: any, flags?: {}): boolean;
     /**
      * Set the value at a specific index.
-     * @param {number} index - The index to set the value at.
-     * @param {*} value - The value to set at the specified index.
-     * @param {*} flags - The flags to use when setting the value.
+     *
+     * @param index
+     * @param value
      */
-    setValueAt(index: number, value: any, flags?: any): void;
+    setValueAt(index: any, value: any, flags?: {}): void;
     get hasSetValue(): boolean;
     setDefaultValue(): void;
     /**
@@ -882,21 +634,22 @@ declare class Component extends Element {
     restoreValue(): void;
     /**
      * Normalize values coming into updateValue.
-     * @param {*} value - The value to normalize before setting.
-     * @returns {*} - The normalized value.
+     *
+     * @param value
+     * @return {*}
      */
     normalizeValue(value: any): any;
     /**
      * Update a value of this component.
-     * @param {*} value - The value to update.
-     * @param {*} flags - The flags to use when updating the value.
-     * @returns {boolean} - If the value changed.
+     *
+     * @param flags
      */
-    updateComponentValue(value: any, flags?: any): boolean;
+    updateComponentValue(value: any, flags?: {}): boolean;
     /**
      * Updates the value of this component plus all sub-components.
-     * @param {...any} args - The arguments to pass to updateValue.
-     * @returns {boolean} - If the value changed.
+     *
+     * @param args
+     * @return {boolean}
      */
     updateValue(...args: any[]): boolean;
     getIcon(name: any, content: any, styles: any, ref?: string): any;
@@ -906,123 +659,130 @@ declare class Component extends Element {
     resetValue(): void;
     /**
      * Determine if the value of this component has changed.
-     * @param {*} newValue - The new value to check.
-     * @param {*} oldValue - The existing value of the component.
-     * @returns {boolean} - TRUE if the value has changed.
+     *
+     * @param newValue
+     * @param oldValue
+     * @return {boolean}
      */
     hasChanged(newValue: any, oldValue: any): boolean;
     /**
      * Update the value on change.
-     * @param {*} flags - The flags to use when triggering the on change event.
-     * @param {boolean} changed - If the value has changed.
-     * @returns {boolean} - If the value changed.
+     *
+     * @param flags
      */
-    updateOnChange(flags?: any, changed?: boolean): boolean;
-    convertNumberOrBoolToString(value: any): any;
+    updateOnChange(flags?: {}, changed?: boolean): boolean;
+    /**
+     * Perform a calculated value operation.
+     *
+     * @param data - The global data object.
+     *
+     * @return {boolean} - If the value changed during calculation.
+     */
+    convertNumberOrBoolToString(value: any): boolean;
     doValueCalculation(dataValue: any, data: any, row: any): any;
     calculateComponentValue(data: any, flags: any, row: any): boolean;
     calculationLocked: boolean | undefined;
     calculatedValue: any;
     /**
      * Performs calculations in this component plus any child components.
-     * @param {*} data - The data to perform the calculation with.
-     * @param {*} flags - The flags to use when calculating the value.
-     * @param {*} row - The contextual row data to use when performing the calculation.
-     * @returns {boolean} - TRUE if the value changed.
+     *
+     * @param args
+     * @return {boolean}
      */
     calculateValue(data: any, flags: any, row: any): boolean;
     /**
      * Set this component's label text and render it.
-     * @param {string} value - The new label text.
+     *
+     * @param value - The new label text.
      */
-    set label(value: string);
+    set label(value: any);
     /**
      * Get this component's label text.
-     * @returns {string} - The label text for this component.
+     *
      */
-    get label(): string;
+    get label(): any;
     /**
      * Get FormioForm element at the root of this component tree.
-     * @returns {*} root - The root component to search from.
+     *
      */
-    getRoot(): any;
+    getRoot(): Component;
     /**
      * Returns the invalid message, or empty string if the component is valid.
-     * @param {*} data - The data to check if the component is valid.
-     * @param {boolean} dirty - If the component is dirty.
-     * @param {boolean} ignoreCondition - If conditions for the component should be ignored when checking validity.
-     * @param {*} row - Contextual row data for this component.
-     * @returns {string} - The message to show when the component is invalid.
+     *
+     * @param data
+     * @param dirty
+     * @return {*}
      */
-    invalidMessage(data: any, dirty: boolean, ignoreCondition: boolean, row: any): string;
+    invalidMessage(data: any, dirty: any, ignoreCondition: any, row: any): any;
     /**
      * Returns if the component is valid or not.
-     * @param {*} data - The data to check if the component is valid.
-     * @param {boolean} dirty - If the component is dirty.
-     * @returns {boolean} - TRUE if the component is valid.
+     *
+     * @param data
+     * @param dirty
+     * @return {boolean}
      */
-    isValid(data: any, dirty: boolean): boolean;
+    isValid(data: any, dirty: any): boolean;
     setComponentValidity(errors: any, dirty: any, silentCheck: any): any;
     /**
      * Interpolate errors from the validation methods.
-     * @param {Array<any>} errors - An array of errors to interpolate.
-     * @returns {Array<any>} - The interpolated errors.
+     * @param {*} errors
+     * @returns
      */
-    interpolateErrors(errors: Array<any>): Array<any>;
+    interpolateErrors(errors: any): any[];
     /**
      * Show component validation errors.
      * @param {*} errors - An array of errors that have occured.
      * @param {*} data - The root submission data.
      * @param {*} row - The contextual row data.
      * @param {*} flags - The flags to perform validation.
-     * @returns {boolean} - TRUE if the component is valid.
+     * @returns
      */
-    showValidationErrors(errors: any, data: any, row: any, flags: any): boolean;
+    showValidationErrors(errors: any, data: any, row: any, flags: any): any;
     /**
      * Perform a component validation.
      * @param {*} data - The root data you wish to use for this component.
      * @param {*} row - The contextual row data you wish to use for this component.
      * @param {*} flags - The flags to control the behavior of the validation.
-     * @returns {Array<any>} - An array of errors if the component is invalid.
+     * @returns
      */
-    validateComponent(data?: any, row?: any, flags?: any): Array<any>;
+    validateComponent(data: any, row: any, flags?: any): any;
     /**
      * Checks the validity of this component and sets the error message if it is invalid.
-     * @param {*} data - The data to check if the component is valid.
-     * @param {boolean} dirty - If the component is dirty.
-     * @param {*} row - The contextual row data for this component.
-     * @param {*} flags - The flags to use when checking the validity.
-     * @param {Array<any>} allErrors - An array of all errors that have occured so that it can be appended when another one occurs here.
-     * @returns {boolean} - TRUE if the component is valid.
+     *
+     * @param data
+     * @param dirty
+     * @param row
+     * @return {boolean}
      */
-    checkComponentValidity(data?: any, dirty?: boolean, row?: any, flags?: any, allErrors?: Array<any>): boolean;
+    checkComponentValidity(data: any, dirty: any, row: any, flags?: {}, allErrors?: any[]): boolean;
     /**
      * Checks the validity of the component.
-     * @param {*} data - The data to check if the component is valid.
-     * @param {boolean} dirty - If the component is dirty.
-     * @param {*} row - The contextual row data for this component.
-     * @param {boolean} silentCheck - If the check should be silent and not set the error messages.
-     * @param {Array<any>} errors - An array of all errors that have occured so that it can be appended when another one occurs here.
-     * @returns {boolean} - TRUE if the component is valid.
+     * @param {*} data
+     * @param {*} dirty
+     * @param {*} row
+     * @param {*} silentCheck
+     * @returns
      */
-    checkValidity(data?: any, dirty?: boolean, row?: any, silentCheck?: boolean, errors?: Array<any>): boolean;
-    checkAsyncValidity(data?: null, dirty?: boolean, row?: null, silentCheck?: boolean, errors?: any[]): boolean;
+    checkValidity(data: any, dirty: any, row: any, silentCheck: any, errors?: any[]): boolean;
+    checkAsyncValidity(data: any, dirty: any, row: any, silentCheck: any, errors?: any[]): boolean;
     /**
      * Check the conditions, calculations, and validity of a single component and triggers an update if
      * something changed.
-     * @param {*} data - The root data of the change event.
-     * @param {*} flags - The flags from this change event.
-     * @param {*} row - The contextual row data for this component.
-     * @returns {void|boolean} - TRUE if no check should be performed on the component.
+     *
+     * @param data - The root data of the change event.
+     * @param flags - The flags from this change event.
+     *
+     * @return boolean - If component is valid or not.
      */
-    checkData(data?: any, flags?: any, row?: any): void | boolean;
+    checkData(data: any, flags: any, row: any): true | undefined;
     checkModal(errors?: any[], dirty?: boolean): void;
     get validationValue(): any;
     isEmpty(value?: any): any;
     isEqual(valueA: any, valueB?: any): any;
     /**
      * Check if a component is eligible for multiple validation
-     * @returns {boolean} - TRUE if the component is eligible for multiple validation.
+     *
+     * @return {boolean}
      */
     validateMultiple(): boolean;
     clearErrorClasses(element?: any): void;
@@ -1032,7 +792,8 @@ declare class Component extends Element {
     /**
      * Determines if the value of this component is hidden from the user as if it is coming from the server, but is
      * protected.
-     * @returns {boolean|*} - TRUE if the value is hidden.
+     *
+     * @return {boolean|*}
      */
     isValueHidden(): boolean | any;
     shouldSkipValidation(data: any, row: any, flags?: {}): boolean;
@@ -1040,8 +801,6 @@ declare class Component extends Element {
     get dataReady(): Promise<void>;
     /**
      * Prints out the value of this component as a string value.
-     * @param {*} value - The value to print out.
-     * @returns {string} - The string representation of the value.
      */
     asString(value: any): string;
     setDisabled(element: any, disabled: any): void;
@@ -1057,17 +816,25 @@ declare class Component extends Element {
     attachLogic(): void;
     /**
      * Get the element information.
-     * @returns {*} - The components "input" DOM element information.
      */
-    elementInfo(): any;
+    elementInfo(): {
+        type: string;
+        component: any;
+        changeEvent: string;
+        attr: {
+            name: any;
+            type: any;
+            class: string;
+            lang: any;
+        };
+    };
     autofocus(): void;
     scrollIntoView(element?: any): void;
-    focus(index?: number): void;
+    focus(index: any): void;
     /**
      * Get `Formio` instance for working with files
-     * @returns {import('@formio/core').Formio} - The Formio instance file service.
      */
-    get fileService(): import("@formio/core").Formio;
+    get fileService(): any;
     resetCaches(): void;
     get previewMode(): boolean;
 }