@types/jqueryui

  • Version 1.12.16
  • Published
  • 82.7 kB
  • 1 dependency
  • MIT license

Install

npm i @types/jqueryui
yarn add @types/jqueryui
pnpm add @types/jqueryui

Overview

TypeScript definitions for jQueryUI

Index

Namespaces

Namespaces

namespace JQueryUI

namespace JQueryUI {}

    interface Accordion

    interface Accordion extends Widget, AccordionOptions {}

      interface AccordionEvent

      interface AccordionEvent {}

        call signature

        (event: JQueryEventObject, ui: AccordionUIParams): void;

          interface AccordionEvents

          interface AccordionEvents {}

            property activate

            activate?: AccordionEvent | undefined;

              property beforeActivate

              beforeActivate?: AccordionEvent | undefined;

                property create

                create?: AccordionEvent | undefined;

                  interface AccordionOptions

                  interface AccordionOptions extends AccordionEvents {}

                    property active

                    active?: any;

                      property animate

                      animate?: any;

                        property collapsible

                        collapsible?: boolean | undefined;

                          property disabled

                          disabled?: boolean | undefined;

                            property event

                            event?: string | undefined;

                              property header

                              header?: string | undefined;

                                property heightStyle

                                heightStyle?: string | undefined;

                                  property icons

                                  icons?: any;

                                    interface AccordionUIParams

                                    interface AccordionUIParams {}

                                      property newHeader

                                      newHeader: JQuery;

                                        property newPanel

                                        newPanel: JQuery;

                                          property oldHeader

                                          oldHeader: JQuery;

                                            property oldPanel

                                            oldPanel: JQuery;

                                              interface Autocomplete

                                              interface Autocomplete extends Widget, AutocompleteOptions {}

                                                property escapeRegex

                                                escapeRegex: (value: string) => string;

                                                  property filter

                                                  filter: (array: any, term: string) => any;

                                                    interface AutocompleteClasses

                                                    interface AutocompleteClasses {}

                                                      property "ui-autocomplete-input"

                                                      'ui-autocomplete-input'?: string | undefined;

                                                        property "ui-autocomplete"

                                                        'ui-autocomplete'?: string | undefined;

                                                          interface AutocompleteEvent

                                                          interface AutocompleteEvent {}

                                                            call signature

                                                            (event: JQueryEventObject, ui: AutocompleteUIParams): void;

                                                              interface AutocompleteEvents

                                                              interface AutocompleteEvents {}

                                                                property change

                                                                change?: AutocompleteEvent | undefined;

                                                                  property close

                                                                  close?: AutocompleteEvent | undefined;

                                                                    property create

                                                                    create?: AutocompleteEvent | undefined;

                                                                      property focus

                                                                      focus?: AutocompleteEvent | undefined;

                                                                        property open

                                                                        open?: AutocompleteEvent | undefined;

                                                                          property response

                                                                          response?: AutocompleteEvent | undefined;

                                                                            property search

                                                                            search?: AutocompleteEvent | undefined;

                                                                              property select

                                                                              select?: AutocompleteEvent | undefined;

                                                                                interface AutocompleteOptions

                                                                                interface AutocompleteOptions extends AutocompleteEvents {}

                                                                                  property appendTo

                                                                                  appendTo?: any;

                                                                                    property autoFocus

                                                                                    autoFocus?: boolean | undefined;

                                                                                      property classes

                                                                                      classes?: AutocompleteClasses | undefined;

                                                                                        property delay

                                                                                        delay?: number | undefined;

                                                                                          property disabled

                                                                                          disabled?: boolean | undefined;

                                                                                            property minLength

                                                                                            minLength?: number | undefined;

                                                                                              property position

                                                                                              position?: any;

                                                                                                property source

                                                                                                source?: any;

                                                                                                  interface AutocompleteUIParams

                                                                                                  interface AutocompleteUIParams {}

                                                                                                    property content

                                                                                                    content?: any;

                                                                                                      property item

                                                                                                      item?: any;
                                                                                                      • The item selected from the menu, if any. Otherwise the property is null

                                                                                                      interface BlindEffect

                                                                                                      interface BlindEffect {}

                                                                                                        property direction

                                                                                                        direction?: string | undefined;

                                                                                                          interface BounceEffect

                                                                                                          interface BounceEffect {}

                                                                                                            property distance

                                                                                                            distance?: number | undefined;

                                                                                                              property times

                                                                                                              times?: number | undefined;

                                                                                                                interface Button

                                                                                                                interface Button extends Widget, ButtonOptions {}

                                                                                                                  interface ButtonOptions

                                                                                                                  interface ButtonOptions {}

                                                                                                                    property click

                                                                                                                    click?: ((event?: Event) => void) | undefined;

                                                                                                                      property disabled

                                                                                                                      disabled?: boolean | undefined;

                                                                                                                        property icons

                                                                                                                        icons?: any;

                                                                                                                          property label

                                                                                                                          label?: string | undefined;

                                                                                                                            property text

                                                                                                                            text?: string | boolean | undefined;

                                                                                                                              interface ClipEffect

                                                                                                                              interface ClipEffect {}

                                                                                                                                property direction

                                                                                                                                direction?: number | undefined;

                                                                                                                                  interface Datepicker

                                                                                                                                  interface Datepicker extends Widget, DatepickerOptions {}

                                                                                                                                    property regional

                                                                                                                                    regional: { [languageCod3: string]: any };

                                                                                                                                      method formatDate

                                                                                                                                      formatDate: (
                                                                                                                                      format: string,
                                                                                                                                      date: Date,
                                                                                                                                      settings?: DatepickerFormatDateOptions
                                                                                                                                      ) => string;

                                                                                                                                        method iso8601Week

                                                                                                                                        iso8601Week: (date: Date) => number;

                                                                                                                                          method noWeekends

                                                                                                                                          noWeekends: (date: Date) => any[];

                                                                                                                                            method parseDate

                                                                                                                                            parseDate: (
                                                                                                                                            format: string,
                                                                                                                                            date: string,
                                                                                                                                            settings?: DatepickerFormatDateOptions
                                                                                                                                            ) => Date;

                                                                                                                                              method setDefaults

                                                                                                                                              setDefaults: (defaults: DatepickerOptions) => void;

                                                                                                                                                interface DatepickerFormatDateOptions

                                                                                                                                                interface DatepickerFormatDateOptions {}

                                                                                                                                                  property dayNames

                                                                                                                                                  dayNames?: string[] | undefined;

                                                                                                                                                    property dayNamesShort

                                                                                                                                                    dayNamesShort?: string[] | undefined;

                                                                                                                                                      property monthNames

                                                                                                                                                      monthNames?: string[] | undefined;

                                                                                                                                                        property monthNamesShort

                                                                                                                                                        monthNamesShort?: string[] | undefined;

                                                                                                                                                          interface DatepickerOptions

                                                                                                                                                          interface DatepickerOptions {}

                                                                                                                                                            property altField

                                                                                                                                                            altField?: any;
                                                                                                                                                            • An input element that is to be updated with the selected date from the datepicker. Use the altFormat option to change the format of the date within this field. Leave as blank for no alternate field.

                                                                                                                                                            property altFormat

                                                                                                                                                            altFormat?: string | undefined;
                                                                                                                                                            • The dateFormat to be used for the altField option. This allows one date format to be shown to the user for selection purposes, while a different format is actually sent behind the scenes. For a full list of the possible formats see the formatDate function

                                                                                                                                                            property appendText

                                                                                                                                                            appendText?: string | undefined;
                                                                                                                                                            • The text to display after each date field, e.g., to show the required format.

                                                                                                                                                            property autohide

                                                                                                                                                            autohide?: boolean | undefined;
                                                                                                                                                            • Set to true to automatically hide the datepicker.

                                                                                                                                                            property autoSize

                                                                                                                                                            autoSize?: boolean | undefined;
                                                                                                                                                            • Set to true to automatically resize the input field to accommodate dates in the current dateFormat.

                                                                                                                                                            property beforeShow

                                                                                                                                                            beforeShow?:
                                                                                                                                                            | ((input: Element, inst: any) => JQueryUI.DatepickerOptions)
                                                                                                                                                            | undefined;
                                                                                                                                                            • A function that takes an input field and current datepicker instance and returns an options object to update the datepicker with. It is called just before the datepicker is displayed.

                                                                                                                                                            property beforeShowDay

                                                                                                                                                            beforeShowDay?: ((date: Date) => any[]) | undefined;
                                                                                                                                                            • A function that takes a date as a parameter and must return an array with: [0]: true/false indicating whether or not this date is selectable [1]: a CSS class name to add to the date's cell or "" for the default presentation [2]: an optional popup tooltip for this date The function is called for each day in the datepicker before it is displayed.

                                                                                                                                                            property buttonImage

                                                                                                                                                            buttonImage?: string | undefined;
                                                                                                                                                            • A URL of an image to use to display the datepicker when the showOn option is set to "button" or "both". If set, the buttonText option becomes the alt value and is not directly displayed.

                                                                                                                                                            property buttonImageOnly

                                                                                                                                                            buttonImageOnly?: boolean | undefined;
                                                                                                                                                            • Whether the button image should be rendered by itself instead of inside a button element. This option is only relevant if the buttonImage option has also been set.

                                                                                                                                                            property buttonText

                                                                                                                                                            buttonText?: string | undefined;
                                                                                                                                                            • The text to display on the trigger button. Use in conjunction with the showOn option set to "button" or "both".

                                                                                                                                                            property calculateWeek

                                                                                                                                                            calculateWeek?: ((date: Date) => string) | undefined;
                                                                                                                                                            • A function to calculate the week of the year for a given date. The default implementation uses the ISO 8601 definition: weeks start on a Monday; the first week of the year contains the first Thursday of the year.

                                                                                                                                                            property changeMonth

                                                                                                                                                            changeMonth?: boolean | undefined;
                                                                                                                                                            • Whether the month should be rendered as a dropdown instead of text.

                                                                                                                                                            property changeYear

                                                                                                                                                            changeYear?: boolean | undefined;
                                                                                                                                                            • Whether the year should be rendered as a dropdown instead of text. Use the yearRange option to control which years are made available for selection.

                                                                                                                                                            property closeText

                                                                                                                                                            closeText?: string | undefined;
                                                                                                                                                            • The text to display for the close link. Use the showButtonPanel option to display this button.

                                                                                                                                                            property constrainInput

                                                                                                                                                            constrainInput?: boolean | undefined;
                                                                                                                                                            • When true, entry in the input field is constrained to those characters allowed by the current dateFormat option.

                                                                                                                                                            property currentText

                                                                                                                                                            currentText?: string | undefined;
                                                                                                                                                            • The text to display for the current day link. Use the showButtonPanel option to display this button.

                                                                                                                                                            property dateFormat

                                                                                                                                                            dateFormat?: string | undefined;
                                                                                                                                                            • The format for parsed and displayed dates. For a full list of the possible formats see the formatDate function.

                                                                                                                                                            property dayNames

                                                                                                                                                            dayNames?: string[] | undefined;
                                                                                                                                                            • The list of long day names, starting from Sunday, for use as requested via the dateFormat option.

                                                                                                                                                            property dayNamesMin

                                                                                                                                                            dayNamesMin?: string[] | undefined;
                                                                                                                                                            • The list of minimised day names, starting from Sunday, for use as column headers within the datepicker.

                                                                                                                                                            property dayNamesShort

                                                                                                                                                            dayNamesShort?: string[] | undefined;
                                                                                                                                                            • The list of abbreviated day names, starting from Sunday, for use as requested via the dateFormat option.

                                                                                                                                                            property defaultDate

                                                                                                                                                            defaultDate?: any;
                                                                                                                                                            • Set the date to highlight on first opening if the field is blank. Specify either an actual date via a Date object or as a string in the current dateFormat, or a number of days from today (e.g. +7) or a string of values and periods ('y' for years, 'm' for months, 'w' for weeks, 'd' for days, e.g. '+1m +7d'), or null for today. Multiple types supported: Date: A date object containing the default date. Number: A number of days from today. For example 2 represents two days from today and -1 represents yesterday. String: A string in the format defined by the dateFormat option, or a relative date. Relative dates must contain value and period pairs; valid periods are "y" for years, "m" for months, "w" for weeks, and "d" for days. For example, "+1m +7d" represents one month and seven days from today.

                                                                                                                                                            property duration

                                                                                                                                                            duration?: string | undefined;
                                                                                                                                                            • Control the speed at which the datepicker appears, it may be a time in milliseconds or a string representing one of the three predefined speeds ("slow", "normal", "fast").

                                                                                                                                                            property endDate

                                                                                                                                                            endDate?: Date | undefined;
                                                                                                                                                            • Set to date to automatically enddate the datepicker.

                                                                                                                                                            property firstDay

                                                                                                                                                            firstDay?: number | undefined;
                                                                                                                                                            • Set the first day of the week: Sunday is 0, Monday is 1, etc.

                                                                                                                                                            property gotoCurrent

                                                                                                                                                            gotoCurrent?: boolean | undefined;
                                                                                                                                                            • When true, the current day link moves to the currently selected date instead of today.

                                                                                                                                                            property hideIfNoPrevNext

                                                                                                                                                            hideIfNoPrevNext?: boolean | undefined;
                                                                                                                                                            • Normally the previous and next links are disabled when not applicable (see the minDate and maxDate options). You can hide them altogether by setting this attribute to true.

                                                                                                                                                            property isRTL

                                                                                                                                                            isRTL?: boolean | undefined;
                                                                                                                                                            • Whether the current language is drawn from right to left.

                                                                                                                                                            property maxDate

                                                                                                                                                            maxDate?: any;
                                                                                                                                                            • The maximum selectable date. When set to null, there is no maximum. Multiple types supported: Date: A date object containing the maximum date. Number: A number of days from today. For example 2 represents two days from today and -1 represents yesterday. String: A string in the format defined by the dateFormat option, or a relative date. Relative dates must contain value and period pairs; valid periods are "y" for years, "m" for months, "w" for weeks, and "d" for days. For example, "+1m +7d" represents one month and seven days from today.

                                                                                                                                                            property minDate

                                                                                                                                                            minDate?: any;
                                                                                                                                                            • The minimum selectable date. When set to null, there is no minimum. Multiple types supported: Date: A date object containing the minimum date. Number: A number of days from today. For example 2 represents two days from today and -1 represents yesterday. String: A string in the format defined by the dateFormat option, or a relative date. Relative dates must contain value and period pairs; valid periods are "y" for years, "m" for months, "w" for weeks, and "d" for days. For example, "+1m +7d" represents one month and seven days from today.

                                                                                                                                                            property monthNames

                                                                                                                                                            monthNames?: string[] | undefined;
                                                                                                                                                            • The list of full month names, for use as requested via the dateFormat option.

                                                                                                                                                            property monthNamesShort

                                                                                                                                                            monthNamesShort?: string[] | undefined;
                                                                                                                                                            • The list of abbreviated month names, as used in the month header on each datepicker and as requested via the dateFormat option.

                                                                                                                                                            property navigationAsDateFormat

                                                                                                                                                            navigationAsDateFormat?: boolean | undefined;
                                                                                                                                                            • Whether the prevText and nextText options should be parsed as dates by the formatDate function, allowing them to display the target month names for example.

                                                                                                                                                            property nextText

                                                                                                                                                            nextText?: string | undefined;
                                                                                                                                                            • The text to display for the next month link. With the standard ThemeRoller styling, this value is replaced by an icon.

                                                                                                                                                            property numberOfMonths

                                                                                                                                                            numberOfMonths?: any;
                                                                                                                                                            • The number of months to show at once. Multiple types supported: Number: The number of months to display in a single row. Array: An array defining the number of rows and columns to display.

                                                                                                                                                            property onChangeMonthYear

                                                                                                                                                            onChangeMonthYear?:
                                                                                                                                                            | ((year: number, month: number, inst: any) => void)
                                                                                                                                                            | undefined;
                                                                                                                                                            • Called when the datepicker moves to a new month and/or year. The function receives the selected year, month (1-12), and the datepicker instance as parameters. this refers to the associated input field.

                                                                                                                                                            property onClose

                                                                                                                                                            onClose?: ((dateText: string, inst: any) => void) | undefined;
                                                                                                                                                            • Called when the datepicker is closed, whether or not a date is selected. The function receives the selected date as text ("" if none) and the datepicker instance as parameters. this refers to the associated input field.

                                                                                                                                                            property onSelect

                                                                                                                                                            onSelect?: ((dateText: string, inst: any) => void) | undefined;
                                                                                                                                                            • Called when the datepicker is selected. The function receives the selected date as text and the datepicker instance as parameters. this refers to the associated input field.

                                                                                                                                                            property prevText

                                                                                                                                                            prevText?: string | undefined;
                                                                                                                                                            • The text to display for the previous month link. With the standard ThemeRoller styling, this value is replaced by an icon.

                                                                                                                                                            property selectOtherMonths

                                                                                                                                                            selectOtherMonths?: boolean | undefined;
                                                                                                                                                            • Whether days in other months shown before or after the current month are selectable. This only applies if the showOtherMonths option is set to true.

                                                                                                                                                            property shortYearCutoff

                                                                                                                                                            shortYearCutoff?: any;
                                                                                                                                                            • The cutoff year for determining the century for a date (used in conjunction with dateFormat 'y'). Any dates entered with a year value less than or equal to the cutoff year are considered to be in the current century, while those greater than it are deemed to be in the previous century. Multiple types supported: Number: A value between 0 and 99 indicating the cutoff year. String: A relative number of years from the current year, e.g., "+3" or "-5".

                                                                                                                                                            property showAnim

                                                                                                                                                            showAnim?: string | undefined;
                                                                                                                                                            • The name of the animation used to show and hide the datepicker. Use "show" (the default), "slideDown", "fadeIn", any of the jQuery UI effects. Set to an empty string to disable animation.

                                                                                                                                                            property showButtonPanel

                                                                                                                                                            showButtonPanel?: boolean | undefined;
                                                                                                                                                            • Whether to display a button pane underneath the calendar. The button pane contains two buttons, a Today button that links to the current day, and a Done button that closes the datepicker. The buttons' text can be customized using the currentText and closeText options respectively.

                                                                                                                                                            property showCurrentAtPos

                                                                                                                                                            showCurrentAtPos?: number | undefined;
                                                                                                                                                            • When displaying multiple months via the numberOfMonths option, the showCurrentAtPos option defines which position to display the current month in.

                                                                                                                                                            property showMonthAfterYear

                                                                                                                                                            showMonthAfterYear?: boolean | undefined;
                                                                                                                                                            • Whether to show the month after the year in the header.

                                                                                                                                                            property showOn

                                                                                                                                                            showOn?: string | undefined;
                                                                                                                                                            • When the datepicker should appear. The datepicker can appear when the field receives focus ("focus"), when a button is clicked ("button"), or when either event occurs ("both").

                                                                                                                                                            property showOptions

                                                                                                                                                            showOptions?: any;
                                                                                                                                                            • If using one of the jQuery UI effects for the showAnim option, you can provide additional settings for that animation via this option.

                                                                                                                                                            property showOtherMonths

                                                                                                                                                            showOtherMonths?: boolean | undefined;
                                                                                                                                                            • Whether to display dates in other months (non-selectable) at the start or end of the current month. To make these days selectable use the selectOtherMonths option.

                                                                                                                                                            property showWeek

                                                                                                                                                            showWeek?: boolean | undefined;
                                                                                                                                                            • When true, a column is added to show the week of the year. The calculateWeek option determines how the week of the year is calculated. You may also want to change the firstDay option.

                                                                                                                                                            property stepMonths

                                                                                                                                                            stepMonths?: number | undefined;
                                                                                                                                                            • Set how many months to move when clicking the previous/next links.

                                                                                                                                                            property weekHeader

                                                                                                                                                            weekHeader?: string | undefined;
                                                                                                                                                            • The text to display for the week of the year column heading. Use the showWeek option to display this column.

                                                                                                                                                            property yearRange

                                                                                                                                                            yearRange?: string | undefined;
                                                                                                                                                            • The range of years displayed in the year drop-down: either relative to today's year ("-nn:+nn"), relative to the currently selected year ("c-nn:c+nn"), absolute ("nnnn:nnnn"), or combinations of these formats ("nnnn:-nn"). Note that this option only affects what appears in the drop-down, to restrict which dates may be selected use the minDate and/or maxDate options.

                                                                                                                                                            property yearSuffix

                                                                                                                                                            yearSuffix?: string | undefined;
                                                                                                                                                            • Additional text to display after the year in the month headers.

                                                                                                                                                            interface Dialog

                                                                                                                                                            interface Dialog extends Widget, DialogOptions {}

                                                                                                                                                              interface DialogButtonOptions

                                                                                                                                                              interface DialogButtonOptions {}

                                                                                                                                                                property click

                                                                                                                                                                click?: ((eventObject: JQueryEventObject) => any) | undefined;

                                                                                                                                                                  property icons

                                                                                                                                                                  icons?: any;

                                                                                                                                                                    property showText

                                                                                                                                                                    showText?: string | boolean | undefined;

                                                                                                                                                                      property text

                                                                                                                                                                      text?: string | undefined;

                                                                                                                                                                        index signature

                                                                                                                                                                        [attr: string]: any;

                                                                                                                                                                          interface DialogClasses

                                                                                                                                                                          interface DialogClasses {}

                                                                                                                                                                            property "ui-dialog-buttonpane"

                                                                                                                                                                            'ui-dialog-buttonpane'?: string | undefined;

                                                                                                                                                                              property "ui-dialog-buttons"

                                                                                                                                                                              'ui-dialog-buttons'?: string | undefined;

                                                                                                                                                                                property "ui-dialog-buttonset"

                                                                                                                                                                                'ui-dialog-buttonset'?: string | undefined;

                                                                                                                                                                                  property "ui-dialog-content"

                                                                                                                                                                                  'ui-dialog-content'?: string | undefined;

                                                                                                                                                                                    property "ui-dialog-dragging"

                                                                                                                                                                                    'ui-dialog-dragging'?: string | undefined;

                                                                                                                                                                                      property "ui-dialog-resizing"

                                                                                                                                                                                      'ui-dialog-resizing'?: string | undefined;

                                                                                                                                                                                        property "ui-dialog-title"

                                                                                                                                                                                        'ui-dialog-title'?: string | undefined;

                                                                                                                                                                                          property "ui-dialog-titlebar-close"

                                                                                                                                                                                          'ui-dialog-titlebar-close'?: string | undefined;

                                                                                                                                                                                            property "ui-dialog-titlebar"

                                                                                                                                                                                            'ui-dialog-titlebar'?: string | undefined;

                                                                                                                                                                                              property "ui-dialog"

                                                                                                                                                                                              'ui-dialog'?: string | undefined;

                                                                                                                                                                                                property "ui-widget-overlay"

                                                                                                                                                                                                'ui-widget-overlay'?: string | undefined;

                                                                                                                                                                                                  interface DialogEvent

                                                                                                                                                                                                  interface DialogEvent {}

                                                                                                                                                                                                    call signature

                                                                                                                                                                                                    (event: JQueryEventObject, ui: DialogUIParams): void;

                                                                                                                                                                                                      interface DialogEvents

                                                                                                                                                                                                      interface DialogEvents {}

                                                                                                                                                                                                        property beforeClose

                                                                                                                                                                                                        beforeClose?: DialogEvent | undefined;

                                                                                                                                                                                                          property close

                                                                                                                                                                                                          close?: DialogEvent | undefined;

                                                                                                                                                                                                            property create

                                                                                                                                                                                                            create?: DialogEvent | undefined;

                                                                                                                                                                                                              property drag

                                                                                                                                                                                                              drag?: DialogEvent | undefined;

                                                                                                                                                                                                                property dragStart

                                                                                                                                                                                                                dragStart?: DialogEvent | undefined;

                                                                                                                                                                                                                  property dragStop

                                                                                                                                                                                                                  dragStop?: DialogEvent | undefined;

                                                                                                                                                                                                                    property focus

                                                                                                                                                                                                                    focus?: DialogEvent | undefined;

                                                                                                                                                                                                                      property open

                                                                                                                                                                                                                      open?: DialogEvent | undefined;

                                                                                                                                                                                                                        property resize

                                                                                                                                                                                                                        resize?: DialogEvent | undefined;

                                                                                                                                                                                                                          property resizeStart

                                                                                                                                                                                                                          resizeStart?: DialogEvent | undefined;

                                                                                                                                                                                                                            property resizeStop

                                                                                                                                                                                                                            resizeStop?: DialogEvent | undefined;

                                                                                                                                                                                                                              interface DialogOptions

                                                                                                                                                                                                                              interface DialogOptions extends DialogEvents {}

                                                                                                                                                                                                                                property appendTo

                                                                                                                                                                                                                                appendTo?: string | undefined;

                                                                                                                                                                                                                                  property autoOpen

                                                                                                                                                                                                                                  autoOpen?: boolean | undefined;

                                                                                                                                                                                                                                    property buttons

                                                                                                                                                                                                                                    buttons?:
                                                                                                                                                                                                                                    | { [buttonText: string]: (event?: Event) => void }
                                                                                                                                                                                                                                    | DialogButtonOptions[]
                                                                                                                                                                                                                                    | undefined;

                                                                                                                                                                                                                                      property classes

                                                                                                                                                                                                                                      classes?: DialogClasses | undefined;

                                                                                                                                                                                                                                        property close

                                                                                                                                                                                                                                        close?: DialogEvent | undefined;

                                                                                                                                                                                                                                          property closeOnEscape

                                                                                                                                                                                                                                          closeOnEscape?: boolean | undefined;

                                                                                                                                                                                                                                            property closeText

                                                                                                                                                                                                                                            closeText?: string | undefined;

                                                                                                                                                                                                                                              property dialogClass

                                                                                                                                                                                                                                              dialogClass?: string | undefined;

                                                                                                                                                                                                                                                property disabled

                                                                                                                                                                                                                                                disabled?: boolean | undefined;

                                                                                                                                                                                                                                                  property draggable

                                                                                                                                                                                                                                                  draggable?: boolean | undefined;

                                                                                                                                                                                                                                                    property height

                                                                                                                                                                                                                                                    height?: number | string | undefined;

                                                                                                                                                                                                                                                      property hide

                                                                                                                                                                                                                                                      hide?: boolean | number | string | DialogShowHideOptions | undefined;

                                                                                                                                                                                                                                                        property maxHeight

                                                                                                                                                                                                                                                        maxHeight?: number | undefined;

                                                                                                                                                                                                                                                          property maxWidth

                                                                                                                                                                                                                                                          maxWidth?: number | undefined;

                                                                                                                                                                                                                                                            property minHeight

                                                                                                                                                                                                                                                            minHeight?: number | undefined;

                                                                                                                                                                                                                                                              property minWidth

                                                                                                                                                                                                                                                              minWidth?: number | undefined;

                                                                                                                                                                                                                                                                property modal

                                                                                                                                                                                                                                                                modal?: boolean | undefined;

                                                                                                                                                                                                                                                                  property open

                                                                                                                                                                                                                                                                  open?: DialogEvent | undefined;

                                                                                                                                                                                                                                                                    property position

                                                                                                                                                                                                                                                                    position?: any;

                                                                                                                                                                                                                                                                      property resizable

                                                                                                                                                                                                                                                                      resizable?: boolean | undefined;

                                                                                                                                                                                                                                                                        property show

                                                                                                                                                                                                                                                                        show?: boolean | number | string | DialogShowHideOptions | undefined;

                                                                                                                                                                                                                                                                          property stack

                                                                                                                                                                                                                                                                          stack?: boolean | undefined;

                                                                                                                                                                                                                                                                            property title

                                                                                                                                                                                                                                                                            title?: string | undefined;

                                                                                                                                                                                                                                                                              property width

                                                                                                                                                                                                                                                                              width?: any;

                                                                                                                                                                                                                                                                                property zIndex

                                                                                                                                                                                                                                                                                zIndex?: number | undefined;

                                                                                                                                                                                                                                                                                  interface DialogShowHideOptions

                                                                                                                                                                                                                                                                                  interface DialogShowHideOptions {}

                                                                                                                                                                                                                                                                                    property delay

                                                                                                                                                                                                                                                                                    delay?: number | undefined;

                                                                                                                                                                                                                                                                                      property duration

                                                                                                                                                                                                                                                                                      duration?: number | undefined;

                                                                                                                                                                                                                                                                                        property easing

                                                                                                                                                                                                                                                                                        easing?: string | undefined;

                                                                                                                                                                                                                                                                                          property effect

                                                                                                                                                                                                                                                                                          effect: string;

                                                                                                                                                                                                                                                                                            interface DialogUIParams

                                                                                                                                                                                                                                                                                            interface DialogUIParams {}

                                                                                                                                                                                                                                                                                              interface Draggable

                                                                                                                                                                                                                                                                                              interface Draggable extends Widget, DraggableOptions, DraggableEvent {}

                                                                                                                                                                                                                                                                                                interface DraggableClasses

                                                                                                                                                                                                                                                                                                interface DraggableClasses {}

                                                                                                                                                                                                                                                                                                  property "ui-draggable-disabled"

                                                                                                                                                                                                                                                                                                  'ui-draggable-disabled'?: string | undefined;

                                                                                                                                                                                                                                                                                                    property "ui-draggable-dragging"

                                                                                                                                                                                                                                                                                                    'ui-draggable-dragging'?: string | undefined;

                                                                                                                                                                                                                                                                                                      property "ui-draggable-handle"

                                                                                                                                                                                                                                                                                                      'ui-draggable-handle'?: string | undefined;

                                                                                                                                                                                                                                                                                                        property "ui-draggable"

                                                                                                                                                                                                                                                                                                        'ui-draggable'?: string | undefined;

                                                                                                                                                                                                                                                                                                          interface DraggableEvent

                                                                                                                                                                                                                                                                                                          interface DraggableEvent {}

                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                            (event: JQueryEventObject, ui: DraggableEventUIParams): void;

                                                                                                                                                                                                                                                                                                              interface DraggableEvents

                                                                                                                                                                                                                                                                                                              interface DraggableEvents {}

                                                                                                                                                                                                                                                                                                                property create

                                                                                                                                                                                                                                                                                                                create?: DraggableEvent | undefined;

                                                                                                                                                                                                                                                                                                                  property drag

                                                                                                                                                                                                                                                                                                                  drag?: DraggableEvent | undefined;

                                                                                                                                                                                                                                                                                                                    property start

                                                                                                                                                                                                                                                                                                                    start?: DraggableEvent | undefined;

                                                                                                                                                                                                                                                                                                                      property stop

                                                                                                                                                                                                                                                                                                                      stop?: DraggableEvent | undefined;

                                                                                                                                                                                                                                                                                                                        interface DraggableEventUIParams

                                                                                                                                                                                                                                                                                                                        interface DraggableEventUIParams {}

                                                                                                                                                                                                                                                                                                                          property helper

                                                                                                                                                                                                                                                                                                                          helper: JQuery;

                                                                                                                                                                                                                                                                                                                            property offset

                                                                                                                                                                                                                                                                                                                            offset: { top: number; left: number };

                                                                                                                                                                                                                                                                                                                              property originalPosition

                                                                                                                                                                                                                                                                                                                              originalPosition: { top: number; left: number };

                                                                                                                                                                                                                                                                                                                                property position

                                                                                                                                                                                                                                                                                                                                position: { top: number; left: number };

                                                                                                                                                                                                                                                                                                                                  interface DraggableOptions

                                                                                                                                                                                                                                                                                                                                  interface DraggableOptions extends DraggableEvents {}

                                                                                                                                                                                                                                                                                                                                    property addClasses

                                                                                                                                                                                                                                                                                                                                    addClasses?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                      property appendTo

                                                                                                                                                                                                                                                                                                                                      appendTo?: any;

                                                                                                                                                                                                                                                                                                                                        property axis

                                                                                                                                                                                                                                                                                                                                        axis?: string | undefined;

                                                                                                                                                                                                                                                                                                                                          property cancel

                                                                                                                                                                                                                                                                                                                                          cancel?: string | undefined;

                                                                                                                                                                                                                                                                                                                                            property classes

                                                                                                                                                                                                                                                                                                                                            classes?: DraggableClasses | undefined;

                                                                                                                                                                                                                                                                                                                                              property connectToSortable

                                                                                                                                                                                                                                                                                                                                              connectToSortable?: Element | Element[] | JQuery | string | undefined;

                                                                                                                                                                                                                                                                                                                                                property containment

                                                                                                                                                                                                                                                                                                                                                containment?: any;

                                                                                                                                                                                                                                                                                                                                                  property cursor

                                                                                                                                                                                                                                                                                                                                                  cursor?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                    property cursorAt

                                                                                                                                                                                                                                                                                                                                                    cursorAt?: any;

                                                                                                                                                                                                                                                                                                                                                      property delay

                                                                                                                                                                                                                                                                                                                                                      delay?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                        property disabled

                                                                                                                                                                                                                                                                                                                                                        disabled?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                          property distance

                                                                                                                                                                                                                                                                                                                                                          distance?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                            property grid

                                                                                                                                                                                                                                                                                                                                                            grid?: number[] | undefined;

                                                                                                                                                                                                                                                                                                                                                              property handle

                                                                                                                                                                                                                                                                                                                                                              handle?: any;

                                                                                                                                                                                                                                                                                                                                                                property helper

                                                                                                                                                                                                                                                                                                                                                                helper?: any;

                                                                                                                                                                                                                                                                                                                                                                  property iframeFix

                                                                                                                                                                                                                                                                                                                                                                  iframeFix?: any;

                                                                                                                                                                                                                                                                                                                                                                    property opacity

                                                                                                                                                                                                                                                                                                                                                                    opacity?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                      property refreshPositions

                                                                                                                                                                                                                                                                                                                                                                      refreshPositions?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                        property revert

                                                                                                                                                                                                                                                                                                                                                                        revert?: any;

                                                                                                                                                                                                                                                                                                                                                                          property revertDuration

                                                                                                                                                                                                                                                                                                                                                                          revertDuration?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                            property scope

                                                                                                                                                                                                                                                                                                                                                                            scope?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                              property scroll

                                                                                                                                                                                                                                                                                                                                                                              scroll?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                property scrollSensitivity

                                                                                                                                                                                                                                                                                                                                                                                scrollSensitivity?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                  property scrollSpeed

                                                                                                                                                                                                                                                                                                                                                                                  scrollSpeed?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                    property snap

                                                                                                                                                                                                                                                                                                                                                                                    snap?: any;

                                                                                                                                                                                                                                                                                                                                                                                      property snapMode

                                                                                                                                                                                                                                                                                                                                                                                      snapMode?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                        property snapTolerance

                                                                                                                                                                                                                                                                                                                                                                                        snapTolerance?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                          property stack

                                                                                                                                                                                                                                                                                                                                                                                          stack?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                            property zIndex

                                                                                                                                                                                                                                                                                                                                                                                            zIndex?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                              interface DropEffect

                                                                                                                                                                                                                                                                                                                                                                                              interface DropEffect {}

                                                                                                                                                                                                                                                                                                                                                                                                property direction

                                                                                                                                                                                                                                                                                                                                                                                                direction?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                  interface Droppable

                                                                                                                                                                                                                                                                                                                                                                                                  interface Droppable extends Widget, DroppableOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                    interface DroppableEvent

                                                                                                                                                                                                                                                                                                                                                                                                    interface DroppableEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                      (event: JQueryEventObject, ui: DroppableEventUIParam): void;

                                                                                                                                                                                                                                                                                                                                                                                                        interface DroppableEvents

                                                                                                                                                                                                                                                                                                                                                                                                        interface DroppableEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                          property activate

                                                                                                                                                                                                                                                                                                                                                                                                          activate?: DroppableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                            property create

                                                                                                                                                                                                                                                                                                                                                                                                            create?: DroppableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                              property deactivate

                                                                                                                                                                                                                                                                                                                                                                                                              deactivate?: DroppableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                property drop

                                                                                                                                                                                                                                                                                                                                                                                                                drop?: DroppableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                  property out

                                                                                                                                                                                                                                                                                                                                                                                                                  out?: DroppableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                    property over

                                                                                                                                                                                                                                                                                                                                                                                                                    over?: DroppableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DroppableEventUIParam

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DroppableEventUIParam {}

                                                                                                                                                                                                                                                                                                                                                                                                                        property draggable

                                                                                                                                                                                                                                                                                                                                                                                                                        draggable: JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                          property helper

                                                                                                                                                                                                                                                                                                                                                                                                                          helper: JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                            property offset

                                                                                                                                                                                                                                                                                                                                                                                                                            offset: { top: number; left: number };

                                                                                                                                                                                                                                                                                                                                                                                                                              property position

                                                                                                                                                                                                                                                                                                                                                                                                                              position: { top: number; left: number };

                                                                                                                                                                                                                                                                                                                                                                                                                                interface DroppableOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                interface DroppableOptions extends DroppableEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                  property accept

                                                                                                                                                                                                                                                                                                                                                                                                                                  accept?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property activeClass

                                                                                                                                                                                                                                                                                                                                                                                                                                    activeClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property addClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                      addClasses?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                        disabled?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property greedy

                                                                                                                                                                                                                                                                                                                                                                                                                                          greedy?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property hoverClass

                                                                                                                                                                                                                                                                                                                                                                                                                                            hoverClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property scope

                                                                                                                                                                                                                                                                                                                                                                                                                                              scope?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property tolerance

                                                                                                                                                                                                                                                                                                                                                                                                                                                tolerance?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface EffectOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface EffectOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property complete

                                                                                                                                                                                                                                                                                                                                                                                                                                                    complete: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                      duration?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property easing

                                                                                                                                                                                                                                                                                                                                                                                                                                                        easing?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property effect

                                                                                                                                                                                                                                                                                                                                                                                                                                                          effect: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ExplodeEffect

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ExplodeEffect {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property pieces

                                                                                                                                                                                                                                                                                                                                                                                                                                                              pieces?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FadeEffect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FadeEffect {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface FoldEffect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface FoldEffect {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property horizFirst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    horizFirst?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      size?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface HighlightEffect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface HighlightEffect {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property color

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          color?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface JQueryPositionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface JQueryPositionOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property at

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              at?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property collision

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                collision?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property my

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  my?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property of

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    of?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property using

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      using?: Function | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property within

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        within?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface KeyCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface KeyCode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property BACKSPACE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            BACKSPACE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property COMMA

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              COMMA: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property DELETE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DELETE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property DOWN

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DOWN: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property END

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    END: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ENTER

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ENTER: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ESCAPE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ESCAPE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property HOME

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          HOME: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property LEFT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            LEFT: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property NUMPAD_ADD

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NUMPAD_ADD: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property NUMPAD_DECIMAL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NUMPAD_DECIMAL: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property NUMPAD_DIVIDE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NUMPAD_DIVIDE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property NUMPAD_ENTER

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NUMPAD_ENTER: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property NUMPAD_MULTIPLY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NUMPAD_MULTIPLY: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property NUMPAD_SUBTRACT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NUMPAD_SUBTRACT: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property PAGE_DOWN

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          PAGE_DOWN: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property PAGE_UP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            PAGE_UP: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property PERIOD

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              PERIOD: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property RIGHT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                RIGHT: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property SPACE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SPACE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property TAB

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TAB: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property UP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      UP: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Menu

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Menu extends Widget, MenuOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MenuEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MenuEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (event: JQueryEventObject, ui: MenuUIParams): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MenuEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MenuEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property blur

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                blur?: MenuEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  create?: MenuEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property focus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    focus?: MenuEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property select

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      select?: MenuEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MenuOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MenuOptions extends MenuEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          disabled?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property icons

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            icons?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property menus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              menus?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                position?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property role

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  role?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MenuUIParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MenuUIParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property item

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      item?: JQuery | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MouseOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MouseOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property cancel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cancel?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property delay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            delay?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property distance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              distance?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Progressbar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Progressbar extends Widget, ProgressbarOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ProgressbarEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ProgressbarEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (event: JQueryEventObject, ui: ProgressbarUIParams): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ProgressbarEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ProgressbarEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property change

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        change?: ProgressbarEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property complete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          complete?: ProgressbarEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            create?: ProgressbarEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ProgressbarOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ProgressbarOptions extends ProgressbarEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                disabled?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property max

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  max?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value?: number | boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ProgressbarUIParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ProgressbarUIParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PuffEffect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PuffEffect {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property percent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          percent?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PulsateEffect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PulsateEffect {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property times

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              times?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Resizable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Resizable extends Widget, ResizableOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ResizableEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ResizableEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (event: JQueryEventObject, ui: ResizableUIParams): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ResizableEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ResizableEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        create?: ResizableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property resize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resize?: ResizableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            start?: ResizableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property stop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stop?: ResizableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ResizableOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ResizableOptions extends ResizableEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property alsoResize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  alsoResize?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property animate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    animate?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property animateDuration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      animateDuration?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property animateEasing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        animateEasing?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property aspectRatio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          aspectRatio?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property autoHide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            autoHide?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cancel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cancel?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property containment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                containment?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property delay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  delay?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    disabled?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property distance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      distance?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ghost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ghost?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property grid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          grid?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property handles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            handles?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property helper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              helper?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property maxHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                maxHeight?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property maxWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  maxWidth?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property minHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    minHeight?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property minWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      minWidth?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResizableUIParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResizableUIParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property element

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          element: JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property helper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            helper: JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property originalElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              originalElement: JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property originalPosition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                originalPosition: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property originalSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  originalSize: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    position: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      size: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ScaleEffect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ScaleEffect {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property direction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          direction?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property origin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            origin?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property percent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              percent?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property scale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scale?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Selectable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Selectable extends Widget, SelectableOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SelectableEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SelectableEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method selected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      selected: (event: any, ui: { selected?: Element | undefined }) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method selecting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        selecting: (event: any, ui: { selecting?: Element | undefined }) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          start: (event: any, ui: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method stop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            stop: (event: any, ui: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method unselected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              unselected: (event: any, ui: { unselected: Element }) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method unselecting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                unselecting: (event: any, ui: { unselecting: Element }) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SelectableOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SelectableOptions extends SelectableEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property autoRefresh

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    autoRefresh?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property cancel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cancel?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property delay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        delay?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          disabled?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property distance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            distance?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              filter?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property tolerance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tolerance?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SelectMenu

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SelectMenu extends Widget, SelectMenuOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SelectMenuClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SelectMenuClasses {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property "ui-selectmenu-button-closed"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'ui-selectmenu-button-closed'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property "ui-selectmenu-button-open"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'ui-selectmenu-button-open'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property "ui-selectmenu-button"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'ui-selectmenu-button'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property "ui-selectmenu-icon"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'ui-selectmenu-icon'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property "ui-selectmenu-menu"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              'ui-selectmenu-menu'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property "ui-selectmenu-open"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'ui-selectmenu-open'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property "ui-selectmenu-optgroup"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'ui-selectmenu-optgroup'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property "ui-selectmenu-text"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'ui-selectmenu-text'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SelectMenuEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SelectMenuEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (event: JQueryEventObject, ui: SelectMenuUIParams): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SelectMenuEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SelectMenuEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property change

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            change?: SelectMenuEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              close?: SelectMenuEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                create?: SelectMenuEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property focus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  focus?: SelectMenuEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    open?: SelectMenuEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property select

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      select?: SelectMenuEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SelectMenuOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SelectMenuOptions extends SelectMenuEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property appendTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          appendTo?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property classes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            classes?: SelectMenuClasses | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              disabled?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property icons

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                icons?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  position?: JQueryPositionOptions | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property width

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    width?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SelectMenuUIParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SelectMenuUIParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property item

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        item?: JQuery | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ShakeEffect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ShakeEffect {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property direction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            direction?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property distance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              distance?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property times

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                times?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SizeEffect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SizeEffect {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property origin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    origin?: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property scale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      scale?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        to?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SlideEffect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SlideEffect {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property direction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            direction?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property distance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              distance?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Slider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Slider extends Widget, SliderOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SliderClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SliderClasses {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property "ui-slider-handle"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'ui-slider-handle'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property "ui-slider-horizontal"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'ui-slider-horizontal'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property "ui-slider-range-max"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'ui-slider-range-max'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property "ui-slider-range-min"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'ui-slider-range-min'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property "ui-slider-range"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'ui-slider-range'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property "ui-slider-vertical"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              'ui-slider-vertical'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property "ui-slider"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'ui-slider'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SliderEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SliderEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (event: JQueryEventObject, ui: SliderUIParams): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SliderEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SliderEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property change

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        change?: SliderEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          create?: SliderEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property slide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            slide?: SliderEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              start?: SliderEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property stop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                stop?: SliderEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SliderOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SliderOptions extends SliderEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property animate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    animate?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property classes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      classes?: SliderClasses | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        disabled?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property highlight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          highlight?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property max

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            max?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property min

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              min?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property orientation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                orientation?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  range?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property step

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    step?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        values?: number[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SliderUIParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SliderUIParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property handle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            handle?: JQuery | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                values?: number[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Sortable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Sortable extends Widget, SortableOptions, SortableEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SortableEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SortableEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (event: JQueryEventObject, ui: SortableUIParams): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SortableEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SortableEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property activate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          activate?: SortableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property beforeStop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            beforeStop?: SortableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property change

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              change?: SortableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property deactivate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                deactivate?: SortableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property out

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  out?: SortableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property over

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    over?: SortableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property receive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      receive?: SortableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        remove?: SortableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property sort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sort?: SortableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            start?: SortableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property stop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stop?: SortableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                update?: SortableEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SortableOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SortableOptions extends SortableEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property appendTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    appendTo?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property attribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      attribute?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property axis

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        axis?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property cancel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cancel?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property connectWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            connectWith?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property containment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              containment?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property cursor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cursor?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property cursorAt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cursorAt?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property delay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    delay?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      disabled?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property distance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        distance?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property dropOnEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          dropOnEmpty?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property forceHelperSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            forceHelperSize?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property forcePlaceholderSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              forcePlaceholderSize?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property grid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                grid?: number[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property handle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  handle?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property helper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    helper?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ((event: JQueryEventObject, element: Sortable) => Element)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property items

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      items?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property opacity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opacity?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property placeholder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          placeholder?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property revert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            revert?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property scroll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scroll?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property scrollSensitivity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scrollSensitivity?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property scrollSpeed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  scrollSpeed?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tolerance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tolerance?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property zIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      zIndex?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SortableUIParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SortableUIParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property helper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          helper: JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property item

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            item: JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property offset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              offset: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property originalPosition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                originalPosition: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property placeholder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  placeholder: JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    position: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property sender

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sender: JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Spinner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Spinner extends Widget, SpinnerOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SpinnerEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SpinnerEvent<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (event: JQueryEventObject, ui: T): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SpinnerEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SpinnerEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property change

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                change?: SpinnerEvent<{}> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  create?: SpinnerEvent<{}> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property spin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    spin?: SpinnerEvent<SpinnerUIParam> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      start?: SpinnerEvent<{}> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property stop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        stop?: SpinnerEvent<{}> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SpinnerOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SpinnerOptions extends SpinnerEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property culture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            culture?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              disabled?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property icons

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                icons?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property incremental

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  incremental?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property max

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    max?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property min

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      min?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property numberFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        numberFormat?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          page?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property step

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            step?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SpinnerUIParam

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SpinnerUIParam {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TabClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TabClasses {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property "ui-tabs-active"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'ui-tabs-active'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property "ui-tabs-anchor"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'ui-tabs-anchor'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property "ui-tabs-collapsible"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'ui-tabs-collapsible'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property "ui-tabs-loading"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'ui-tabs-loading'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property "ui-tabs-nav"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'ui-tabs-nav'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property "ui-tabs-panel"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              'ui-tabs-panel'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property "ui-tabs-tab"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'ui-tabs-tab'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property "ui-tabs"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'ui-tabs'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Tabs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Tabs extends Widget, TabsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface TabsActivationUIParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface TabsActivationUIParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property newPanel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        newPanel: JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property newTab

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          newTab: JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property oldPanel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            oldPanel: JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property oldTab

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              oldTab: JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface TabsBeforeLoadUIParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface TabsBeforeLoadUIParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ajaxSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ajaxSettings: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property jqXHR

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    jqXHR: JQueryXHR;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property panel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      panel: JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tab

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tab: JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface TabsCreateOrLoadUIParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface TabsCreateOrLoadUIParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property panel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            panel: JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property tab

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tab: JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface TabsEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface TabsEvent<UI> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (event: JQueryEventObject, ui: UI): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TabsEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TabsEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property activate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      activate?: TabsEvent<TabsActivationUIParams> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property beforeActivate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        beforeActivate?: TabsEvent<TabsActivationUIParams> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property beforeLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          beforeLoad?: TabsEvent<TabsBeforeLoadUIParams> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            create?: TabsEvent<TabsCreateOrLoadUIParams> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property load

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              load?: TabsEvent<TabsCreateOrLoadUIParams> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface TabsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface TabsOptions extends TabsEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property active

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  active?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property classes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    classes?: TabClasses | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property collapsible

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      collapsible?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        disabled?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property event

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          event?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property heightStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            heightStyle?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property hide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hide?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                show?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Tooltip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Tooltip extends Widget, TooltipOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TooltipEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TooltipEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (event: JQueryEventObject, ui: TooltipUIParams): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TooltipEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TooltipEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          close?: TooltipEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            open?: TooltipEvent | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface TooltipOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface TooltipOptions extends TooltipEvents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property classes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                classes?: { [key: string]: string } | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  content?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    disabled?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property hide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hide?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property items

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        items?: string | JQuery | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          position?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            show?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property tooltipClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tooltipClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property track

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                track?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TooltipUIParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TooltipUIParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TransferEffect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TransferEffect {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      className?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        to?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface UI

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface UI {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property accordion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            accordion: Accordion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property autocomplete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              autocomplete: Autocomplete;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property button

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                button: Button;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property buttonset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  buttonset: Button;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property datepicker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    datepicker: Datepicker;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property dialog

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dialog: Dialog;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property keyCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keyCode: KeyCode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property menu

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          menu: Menu;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property progressbar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            progressbar: Progressbar;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property selectmenu

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              selectmenu: SelectMenu;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property slider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                slider: Slider;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property spinner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  spinner: Spinner;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tabs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tabs: Tabs;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tooltip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tooltip: Tooltip;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        version: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method mouse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          mouse: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (method: string): JQuery;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (options: MouseOptions): JQuery;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (optionLiteral: string, optionName: string, optionValue: any): JQuery;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (optionLiteral: string, optionValue: any): any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Widget

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Widget {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (methodName: string): JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (options: WidgetOptions): JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (options: AccordionOptions): JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (optionLiteral: string, optionName: string): any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (optionLiteral: string, options: WidgetOptions): any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (optionLiteral: string, optionName: string, optionValue: any): JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <T>(name: string, prototype: T & ThisType<T & WidgetCommonProperties>): JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            base: Function,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            prototype: T & ThisType<T & WidgetCommonProperties>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface WidgetCommonProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface WidgetCommonProperties {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property defaultElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                defaultElement: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property document

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  document: Document;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property element

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    element: JQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property namespace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property uuid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        uuid: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property widgetEventPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          widgetEventPrefix: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property widgetFullName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            widgetFullName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property window

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              window: Window;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface WidgetOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface WidgetOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  disabled?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property hide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hide?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      show?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/jqueryui.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/jqueryui)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <a href="https://www.jsdocs.io/package/@types/jqueryui"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>