AccessKeyedElement: JS/PHP
    Basic:
        description: MISMATCH
          JS: "AccessKeyedElement is mixed into other classes to provide an `accesskey` attribute. Accesskeys allow an user to go to a specific element by using a shortcut combination of a browser specific keys + the key set to the field. @example // AccessKeyedElement provides an 'accesskey' attribute to the // ButtonWidget class var button = new ButtonWidget( { label: 'Button with Accesskey', accessKey: 'k' } ); $( 'body' ).append( button.$element );"
          PHP: "Element with an accesskey. Accesskeys allow an user to go to a specific element by using a shortcut combination of a browser specific keys + the key set to the field."
    Methods:
        #constructor: PHP missing
        getAccessKey: MISMATCH
            description: MISMATCH
              JS: "Get accesskey."
              PHP: "Get AccessKey."
            return: MISMATCH
                description: MISMATCH
                  JS: "accessKey string"
                  PHP: "Accesskey string"
        initializeAccessKeyedElement: JS missing
        setAccessKey: MISMATCH
            description: MISMATCH
              JS: "Set accesskey."
              PHP: "Set access key."
            params: MISMATCH
                accessKey: MISMATCH
                    description: MISMATCH
                      JS: "Key, a function that returns a key, or `null` for no accesskey"
                      PHP: "Tag's access key, use empty string to remove"
                    type: MISMATCH
                      JS: "string|null"
                      PHP: "string"
            return: JS missing
        setAccessKeyedElement: PHP missing
    Properties:
        accessKey: MISMATCH
            description: MISMATCH
              JS: "The access key, a function that returns a key, or `null` for no accesskey."
              PHP: "Accesskey"
            static: PHP missing
            type: MISMATCH
              JS: "string|null"
              PHP: "string"
        accessKeyed: JS missing

ActionFieldLayout: JS/PHP
    Basic:
        description: MISMATCH
          JS: "ActionFieldLayouts are used with FieldsetLayout. The layout consists of a field-widget, a button, and an optional label and/or help text. The field-widget (e.g., a {@link OO.ui.TextInputWidget TextInputWidget}), is required and is specified before any optional configuration settings. Labels can be aligned in one of four ways: - **left**: The label is placed before the field-widget and aligned with the left margin. A left-alignment is used for forms with many fields. - **right**: The label is placed before the field-widget and aligned to the right margin. A right-alignment is used for long but familiar forms which users tab through, verifying the current field with a quick glance at the label. - **top**: The label is placed above the field-widget. A top-alignment is used for brief forms that users fill out from top to bottom. - **inline**: The label is placed after the field-widget and aligned to the left. An inline-alignment is best used with checkboxes or radio buttons. Help text is accessed via a help icon that appears in the upper right corner of the rendered field layout when help text is specified. @example // Example of an ActionFieldLayout var actionFieldLayout = new OO.ui.ActionFieldLayout( new OO.ui.TextInputWidget( { placeholder: 'Field widget' } ), new OO.ui.ButtonWidget( { label: 'Button' } ), { label: 'An ActionFieldLayout. This label is aligned top', align: 'top', help: 'This is help text' } ); $( 'body' ).append( actionFieldLayout.$element );"
          PHP: "Layout made of a field, button and optional label."
    Methods:
        #constructor: MISMATCH
            params: MISMATCH
                buttonWidget: MISMATCH
                    description: MISMATCH
                      JS: "Button widget"
                      PHP: "Field widget"
    Properties:
        buttonWidget: JS missing

ApexTheme: JS/PHP
    Methods:
        #constructor: PHP missing

BlankTheme: JS/PHP
    Basic:
        parent: MISMATCH
          JS: "{Theme}"
          PHP: "Theme"
    Methods:
        #constructor: PHP missing

ButtonElement: JS/PHP
    Basic:
        description: MISMATCH
          JS: "ButtonElement is often mixed into other classes to generate a button, which is a clickable interface element that can be configured with access keys for accessibility. See the [OOjs UI documentation on MediaWiki] [1] for examples. [1]: https://www.mediawiki.org/wiki/OOjs_UI/Widgets/Buttons_and_SwitchesButtons()"
          PHP: "Element with a button. Buttons are used for controls which can be clicked. They can be configured to use tab indexing and access keys for accessibility purposes."
    Methods:
        #constructor: PHP missing
        initializeButtonElement: JS missing
        isActive: PHP missing
        onClick: PHP missing
        onKeyDown: PHP missing
        onKeyPress: PHP missing
        onKeyUp: PHP missing
        onMouseDown: PHP missing
        onMouseUp: PHP missing
        setActive: PHP missing
        setButtonElement: PHP missing
        toggleFramed: MISMATCH
            description: MISMATCH
              JS: "Render the button with or without a frame. Omit the `framed` parameter to toggle the button frame on and off."
              PHP: "Toggle frame."
            return: JS missing
    Properties:
        button: JS missing
        cancelButtonMouseDownEvents: PHP missing
        framed: JS missing

ButtonGroupWidget: JS/PHP
    Basic:
        description: MISMATCH
          JS: "A ButtonGroupWidget groups related buttons and is used together with ButtonWidget and its subclasses. Each button in a group is addressed by a unique reference. Buttons can be added, removed, and cleared from the group. @example // Example: A ButtonGroupWidget with two buttons var button1 = new OO.ui.PopupButtonWidget( { label: 'Select a category', icon: 'menu', popup: { $content: $( '<p>List of categories...</p>' ), padded: true, align: 'left' } } ); var button2 = new OO.ui.ButtonWidget( { label: 'Add item' }); var buttonGroup = new OO.ui.ButtonGroupWidget( { items: [button1, button2] } ); $( 'body' ).append( buttonGroup.$element );"
          PHP: "Group widget for multiple related buttons. Use together with ButtonWidget."

ButtonInputWidget: JS/PHP
    Basic:
        description: MISMATCH
          JS: "ButtonInputWidget is used to submit HTML forms and is intended to be used within a FormLayout. If you do not need the button to work with HTML forms, you probably want to use OO.ui.ButtonWidget instead. Button input widgets can be rendered as either an HTML `<button>` (the default) or an HTML `<input>` tags. See the [OOjs UI documentation on MediaWiki] [1] for more information. @example // A ButtonInputWidget rendered as an HTML button, the default. var button = new OO.ui.ButtonInputWidget( { label: 'Input button', icon: 'check', value: 'check' } ); $( 'body' ).append( button.$element ); [1]: https://www.mediawiki.org/wiki/OOjs_UI/Widgets/InputsButton_inputs()"
          PHP: "A button that is an input widget. Intended to be used within a FormLayout."
        mixins: MISMATCH
          JS: ["ButtonElement", "IconElement", "IndicatorElement", "LabelElement", "TitledElement"]
          PHP: ["ButtonElement", "IconElement", "IndicatorElement", "LabelElement"]
    Methods:
        #constructor: MISMATCH
            config: MISMATCH
                type: MISMATCH
                    description: MISMATCH
                      JS: "The value of the HTML `'type'` attribute: 'button', 'submit' or 'reset'."
                      PHP: "HTML tag `type` attribute, may be 'button', 'submit' or 'reset'"
                useInputTag: MISMATCH
                    description: MISMATCH
                      JS: "Use an `<input>` tag instead of a `<button>` tag, the default. Widgets configured to be an `<input>` do not support {@link icon() icons} and {@link indicator() indicators}, non-plaintext {@link label() labels}, or {@link value() values}. In general, useInputTag should only be set to `true` when there\u2019s need to support IE 6 in a form with multiple buttons."
                      PHP: "Whether to use `<input>` rather than `<button>`. Only useful if you need IE 6 support in a form with multiple buttons. If you use this option, icons and indicators will not be displayed, it won't be possible to have a non-plaintext label, and it won't be possible to set a value (which will internally become identical to the label)."
        setLabel: MISMATCH
            description: MISMATCH
              JS: "Set label value. If useInputTag() is `true`, the label is set as the `value` of the `<input>` tag."
              PHP: "Set label value. Overridden to support setting the 'value' of `<input>` elements."
            params: MISMATCH
                label: MISMATCH
                    description: MISMATCH
                      JS: "Label nodes, text, a function that returns nodes or text, or `null` for no label"
                      PHP: "Label text"
            return: JS missing
        setValue: MISMATCH
            description: MISMATCH
              JS: "Set the value of the input. This method is disabled for button inputs configured as {@link useInputTag() <input> tags}, as they do not support {@link value() values}."
              PHP: "Set the value of the input. Overridden to disable for `<input>` elements, which have value identical to the label."
            return: JS missing
    Properties:
        supportsSimpleLabel: JS missing
        useInputTag: JS missing

ButtonWidget: JS/PHP
    Basic:
        description: MISMATCH
          JS: "ButtonWidget is a generic widget for buttons. A wide variety of looks, feels, and functionality can be customized via the class\u2019s configuration options and methods. Please see the [OOjs UI documentation on MediaWiki] [1] for more information and examples. [1]: https://www.mediawiki.org/wiki/OOjs_UI/Widgets/Buttons_and_Switches @example // A button widget var button = new ButtonWidget( { label: 'Button with Icon', icon: 'remove', iconTitle: 'Remove' } ); $( 'body' ).append( button.$element ); NOTE: HTML form buttons should use the OO.ui.ButtonInputWidget class."
          PHP: "Generic widget for buttons."
    Methods:
        #constructor: MISMATCH
            config: MISMATCH
                href: MISMATCH
                    description: MISMATCH
                      JS: "Hyperlink to visit when the button is clicked."
                      PHP: "Hyperlink to visit when clicked"
                noFollow: MISMATCH
                    default: JS missing
                    description: MISMATCH
                      JS: "Search engine traversal hint (default: true)"
                      PHP: "Search engine traversal hint"
                target: MISMATCH
                    description: MISMATCH
                      JS: "The frame or window in which to open the hyperlink."
                      PHP: "Target to open hyperlink in"
        isActive: JS missing
        onDisable: PHP missing
        setActive: JS missing
        setHref: MISMATCH
            return: JS missing
        setNoFollow: MISMATCH
            return: JS missing
        setTarget: MISMATCH
            return: JS missing
        updateHref: MISMATCH
            description: MISMATCH
              JS: "Update the `href` attribute, in case of changes to href or disabled state."
              PHP: "Update the href attribute, in case of changes to href or disabled state."
            return: JS missing
            visibility: MISMATCH
              JS: :private
              PHP: :public
    Properties:
        active: JS missing
        href: JS missing
        noFollow: JS missing
        target: JS missing

CheckboxInputWidget: JS/PHP
    Basic:
        description: MISMATCH
          JS: "CheckboxInputWidgets, like HTML checkboxes, can be selected and/or configured with a value. Note that these {@link InputWidget input widgets} are best laid out in {@link OO.ui.FieldLayout field layouts} that use the {@link OO.ui.FieldLayoutalign() inline} alignment. For more information, please see the [OOjs UI documentation on MediaWiki][1]. This widget can be used inside an HTML form, such as a OO.ui.FormLayout. @example // An example of selected, unselected, and disabled checkbox inputs var checkbox1=new OO.ui.CheckboxInputWidget( { value: 'a', selected: true } ); var checkbox2=new OO.ui.CheckboxInputWidget( { value: 'b' } ); var checkbox3=new OO.ui.CheckboxInputWidget( { value:'c', disabled: true } ); // Create a fieldset layout with fields for each checkbox. var fieldset = new OO.ui.FieldsetLayout( { label: 'Checkboxes' } ); fieldset.addItems( [ new OO.ui.FieldLayout( checkbox1, { label: 'Selected checkbox', align: 'inline' } ), new OO.ui.FieldLayout( checkbox2, { label: 'Unselected checkbox', align: 'inline' } ), new OO.ui.FieldLayout( checkbox3, { label: 'Disabled checkbox', align: 'inline' } ), ] ); $( 'body' ).append( fieldset.$element ); [1]: https://www.mediawiki.org/wiki/OOjs_UI/Widgets/Inputs"
          PHP: "Checkbox input widget."
        mixins: MISMATCH
          JS: ["the"]
          PHP: {}
    Methods:
        #constructor: MISMATCH
            config: MISMATCH
                selected: MISMATCH
                    description: MISMATCH
                      JS: "Select the checkbox initially. By default, the checkbox is not selected."
                      PHP: "Whether the checkbox is initially selected"
        setSelected: MISMATCH
            params: MISMATCH
                state: MISMATCH
                    description: MISMATCH
                      JS: "`true` for selected"
                      PHP: "Whether the checkbox is selected"
            return: JS missing
    Properties:
        selected: JS missing

CheckboxMultiselectInputWidget: JS/PHP
    Basic:
        description: MISMATCH
          JS: "CheckboxMultiselectInputWidget is a {@link CheckboxMultiselectWidget CheckboxMultiselectWidget} intended to be used within a HTML form, such as a OO.ui.FormLayout. The selected values are synchronized with the value of HTML `<input type=checkbox>` tags. Please see the [OOjs UI documentation on MediaWiki][1] for more information about input widgets. @example // Example: A CheckboxMultiselectInputWidget with three options var multiselectInput = new OO.ui.CheckboxMultiselectInputWidget( { options: [ { data: 'a', label: 'First' }, { data: 'b', label: 'Second'}, { data: 'c', label: 'Third' } ] } ); $( 'body' ).append( multiselectInput.$element ); [1]: https://www.mediawiki.org/wiki/OOjs_UI/Widgets/Inputs"
          PHP: "Multiple checkbox input widget. Intended to be used within a FormLayout."
    Methods:
        #constructor: MISMATCH
            config: MISMATCH
                options: MISMATCH
                    default: PHP missing
                    description: MISMATCH
                      JS: "Array of menu options in the format `{ data: \u2026, label: \u2026, disabled: \u2026 }`"
                      PHP: "Array of menu options in the format `[ 'data' => \u2026, 'label' => \u2026, 'disabled' => \u2026 ]`"
                    type: MISMATCH
                      JS: "Object[]"
                      PHP: "array[]"
        cleanUpValue: MISMATCH
            visibility: MISMATCH
              JS: :public
              PHP: :protected
        setOptions: MISMATCH
            params: MISMATCH
                options: MISMATCH
                    description: MISMATCH
                      JS: "Array of menu options in the format `{ data: \u2026, label: \u2026, disabled: \u2026 }`"
                      PHP: "Array of menu options in the format `[ 'data' => \u2026, 'label' => \u2026, 'disabled' => \u2026 ]`"
                    type: MISMATCH
                      JS: "Object[]"
                      PHP: "array[]"
            return: JS missing
        setValue: JS missing
    Properties:
        fields: JS missing
        name: JS missing
        value: JS missing

ComboBoxInputWidget: JS/PHP
    Basic:
        description: MISMATCH
          JS: "ComboBoxInputWidgets combine a {@link TextInputWidget text input} (where a value can be entered manually) and a {@link OO.ui.MenuSelectWidget menu of options} (from which a value can be chosen instead). Users can choose options from the combo box in one of two ways: - by typing a value in the text input field. If the value exactly matches the value of a menu option, that option will appear to be selected. - by choosing a value from the menu. The value of the chosen option will then appear in the text input field. After the user chooses an option, its `data` will be used as a new value for the widget. A `label` also can be specified for each option: if given, it will be shown instead of the `data` in the dropdown menu. This widget can be used inside an HTML form, such as a OO.ui.FormLayout. For more information about menus and options, please see the [OOjs UI documentation on MediaWiki][1]. @example // Example: A ComboBoxInputWidget. var comboBox = new OO.ui.ComboBoxInputWidget( { value: 'Option 1', options: [ { data: 'Option 1' }, { data: 'Option 2' }, { data: 'Option 3' } ] } ); $( 'body' ).append( comboBox.$element ); @example // Example: A ComboBoxInputWidget with additional option labels. var comboBox = new OO.ui.ComboBoxInputWidget( { value: 'Option 1', options: [ { data: 'Option 1', label: 'Option One' }, { data: 'Option 2', label: 'Option Two' }, { data: 'Option 3', label: 'Option Three' } ] } ); $( 'body' ).append( comboBox.$element ); [1]: https://www.mediawiki.org/wiki/OOjs_UI/Widgets/Selects_and_OptionsMenu_selects_and_options()"
          PHP: "Combo box input widget, wrapping a text input with `<datalist>`. Intended to be used within a FormLayout."
    Methods:
        #constructor: MISMATCH
            config: MISMATCH
                $overlay: PHP missing
                menu: PHP missing
                options: MISMATCH
                    default: PHP missing
                    description: MISMATCH
                      JS: "Array of menu options in the format `{ data: \u2026, label: \u2026 }`"
                      PHP: "Array of menu options in the format `[ 'data' => \u2026, 'label' => \u2026 ]`"
                    type: MISMATCH
                      JS: "Object[]"
                      PHP: "array[]"
        getInput: PHP missing
        getMenu: PHP missing
        onDropdownButtonClick: PHP missing
        onInputChange: PHP missing
        onInputEnter: PHP missing
        onMenuChoose: PHP missing
        onMenuItemsChange: PHP missing
        setOptions: MISMATCH
            params: MISMATCH
                options: MISMATCH
                    description: MISMATCH
                      JS: "Array of menu options in the format `{ data: \u2026, label: \u2026 }`"
                      PHP: "Array of menu options in the format `[ 'data' => \u2026, 'label' => \u2026 ]`"
                    type: MISMATCH
                      JS: "Object[]"
                      PHP: "array[]"
            return: JS missing
    Properties:
        options: JS missing

DropdownInputWidget: JS/PHP
    Basic:
        description: MISMATCH
          JS: "DropdownInputWidget is a {@link DropdownWidget DropdownWidget} intended to be used within an HTML form, such as a OO.ui.FormLayout. The selected value is synchronized with the value of a hidden HTML `input` tag. Please see the [OOjs UI documentation on MediaWiki][1] for more information about input widgets. A DropdownInputWidget always has a value (one of the options is always selected), unless there are no options. If no `value` configuration option is provided, the first option is selected. If you need a state representing no value (no option being selected), use a DropdownWidget. This and OO.ui.RadioSelectInputWidget support the same configuration options. @example // Example: A DropdownInputWidget with three options var dropdownInput = new OO.ui.DropdownInputWidget( { options: [ { data: 'a', label: 'First' }, { data: 'b', label: 'Second'}, { data: 'c', label: 'Third' } ] } ); $( 'body' ).append( dropdownInput.$element ); [1]: https://www.mediawiki.org/wiki/OOjs_UI/Widgets/Inputs"
          PHP: "Dropdown input widget, wrapping a `<select>` element. Intended to be used within a FormLayout."
        mixins: MISMATCH
          JS: ["TitledElement"]
          PHP: {}
    Methods:
        #constructor: MISMATCH
            config: MISMATCH
                dropdown: PHP missing
                options: MISMATCH
                    default: PHP missing
                    description: MISMATCH
                      JS: "Array of menu options in the format `{ data: \u2026, label: \u2026 }`"
                      PHP: "Array of menu options in the format `[ 'data' => \u2026, 'label' => \u2026 ]`"
                    type: MISMATCH
                      JS: "Object[]"
                      PHP: "array[]"
        onMenuSelect: PHP missing
        setOptions: MISMATCH
            params: MISMATCH
                options: MISMATCH
                    description: MISMATCH
                      JS: "Array of menu options in the format `{ data: \u2026, label: \u2026 }`"
                      PHP: "Array of menu options in the format `[ 'data' => \u2026, 'label' => \u2026 ]`"
                    type: MISMATCH
                      JS: "Object[]"
                      PHP: "array[]"
            return: JS missing
    Properties:
        options: JS missing

Element: JS/PHP
    Basic:
        description: MISMATCH
          JS: "Each Element represents a rendering in the DOM\u2014a button or an icon, for example, or anything that is visible to a user. Unlike {@link Widget widgets}, plain elements usually do not have events connected to them and can't be interacted with."
          PHP: "DOM element abstraction."
        parent: JS missing
    Methods:
        #constructor: MISMATCH
            config: MISMATCH
                $content: PHP missing
                $element: PHP missing
                classes: MISMATCH
                    description: MISMATCH
                      JS: "The names of the CSS classes to apply to the element. CSS styles are added to the top level (e.g., the outermost div) of the element. See the [OOjs UI documentation on MediaWiki][2] for an example. [2]: https://www.mediawiki.org/wiki/OOjs_UI/Widgets/Buttons_and_SwitchescssExample()"
                      PHP: "CSS class names to add"
                content: MISMATCH
                    description: MISMATCH
                      JS: "An array of content elements to append (after text()). Strings will be html-escaped; use an HtmlSnippet to append raw HTML. Instances of OO.ui.Element will have their $element appended."
                      PHP: "Content to append (after text), strings or Element arrays. Strings will be HTML-escaped for output, use an HtmlSnippet instance to prevent that."
                    type: MISMATCH
                      JS: "Array"
                      PHP: "array"
                data: MISMATCH
                    description: MISMATCH
                      JS: "Custom data of any type or combination of types (e.g., string, number, array, array). Data can also be specified with the setData() method."
                      PHP: "Element data"
                    type: MISMATCH
                      JS: "Mixed"
                      PHP: "mixed"
                id: MISMATCH
                    description: MISMATCH
                      JS: "The HTML id attribute used in the rendered tag."
                      PHP: "HTML id attribute"
        configFromHtmlAttributes: JS missing
        getClosestScrollableElementContainer: PHP missing
        getConfig: JS missing
        getData: MISMATCH
            return: MISMATCH
                type: MISMATCH
                  JS: "Mixed"
                  PHP: "mixed"
        getDir: JS missing
        getElementDocument: PHP missing
        getElementGroup: PHP missing
        getElementWindow: PHP missing
        getJavaScriptClassName: JS missing
        getScrollLeft: PHP missing
        getSerializedConfig: JS missing
        isElementAttached: PHP missing
        isVisible: PHP missing
        registerConfigCallback: JS missing
        restorePreInfuseState: PHP missing
        scrollElementIntoView: PHP missing
        setData: MISMATCH
            params: MISMATCH
                data: MISMATCH
                    type: MISMATCH
                      JS: "Mixed"
                      PHP: "mixed"
            return: JS missing
        setDefaultDir: JS missing
        setElementGroup: PHP missing
        toString: JS missing
        toggle: PHP missing
        updateThemeClasses: PHP missing
    Properties:
        configCallbacks: JS missing
        data: JS missing
        defaultDir: JS missing
        gatherPreInfuseState: PHP missing
        getBorders: PHP missing
        getClosestScrollableContainer: PHP missing
        getDimensions: PHP missing
        getDir: PHP missing
        getDocument: PHP missing
        getFrameOffset: PHP missing
        getJQuery: PHP missing
        getRelativePosition: PHP missing
        getRootScrollableElement: PHP missing
        getWindow: PHP missing
        infuse: PHP missing
        ownClasses: JS missing
        reconsiderScrollbars: PHP missing
        reusePreInfuseDOM: PHP missing
        scrollIntoView: PHP missing
        tagName: MISMATCH
            description: MISMATCH
              JS: "The name of the HTML tag used by the element. The static value may be ignored if the getTagName() method is overridden."
              PHP: "HTML tag name. This may be ignored if getTagName() is overridden."
        unsafeInfuse: PHP missing

FieldLayout: JS/PHP
    Basic:
        description: MISMATCH
          JS: "FieldLayouts are used with FieldsetLayout. Each FieldLayout requires a field-widget, which is a widget that is specified by reference before any optional configuration settings. Field layouts can be configured with help text and/or labels. Labels are aligned in one of four ways: - **left**: The label is placed before the field-widget and aligned with the left margin. A left-alignment is used for forms with many fields. - **right**: The label is placed before the field-widget and aligned to the right margin. A right-alignment is used for long but familiar forms which users tab through, verifying the current field with a quick glance at the label. - **top**: The label is placed above the field-widget. A top-alignment is used for brief forms that users fill out from top to bottom. - **inline**: The label is placed after the field-widget and aligned to the left. An inline-alignment is best used with checkboxes or radio buttons. Help text is accessed via a help icon that appears in the upper right corner of the rendered field layout. Please see the [OOjs UI documentation on MediaWiki] [1] for examples and more information. [1]: https://www.mediawiki.org/wiki/OOjs_UI/Layouts/Fields_and_Fieldsets"
          PHP: "Layout made of a field and optional label. Available label alignment modes include: - left: Label is before the field and aligned away from it, best for when the user will be scanning for a specific label in a form with many fields - right: Label is before the field and aligned toward it, best for forms the user is very familiar with and will tab through field checking quickly to verify which field they are in - top: Label is before the field and above it, best for when the user will need to fill out all fields from top to bottom in a form with few fields - inline: Label is after the field and aligned toward it, best for small boolean fields like checkboxes or radio buttons"
    Methods:
        #constructor: MISMATCH
            config: MISMATCH
                $overlay: PHP missing
                align: MISMATCH
                    description: MISMATCH
                      JS: "Alignment of the label: 'left', 'right', 'top' or 'inline'"
                      PHP: "Alignment mode, either 'left', 'right', 'top' or 'inline'"
                errors: MISMATCH
                    description: MISMATCH
                      JS: "Error messages about the widget, which will be displayed below the widget. The array may contain strings or HtmlSnippet instances."
                      PHP: "Error messages about the widget, as strings or HtmlSnippet instances."
                    type: MISMATCH
                      JS: "Array"
                      PHP: "array"
                help: MISMATCH
                    description: MISMATCH
                      JS: "Help text. When help text is specified, a \"help\" icon will appear in the upper-right corner of the rendered field; clicking it will display the text in a popup. For important messages, you are advised to use `notices`, as they are always shown."
                      PHP: "Explanatory text shown as a '?' icon."
                notices: MISMATCH
                    description: MISMATCH
                      JS: "Notices about the widget, which will be displayed below the widget. The array may contain strings or HtmlSnippet instances."
                      PHP: "Notices about the widget, as strings or HtmlSnippet instances."
                    type: MISMATCH
                      JS: "Array"
                      PHP: "array"
        getField: MISMATCH
            description: MISMATCH
              JS: "Get the widget contained by the field."
              PHP: "Get the field."
        isFieldInline: MISMATCH
            return: MISMATCH
                type: MISMATCH
                  JS: "boolean"
                  PHP: "bool"
        makeMessage: MISMATCH
            visibility: MISMATCH
              JS: :protected
              PHP: :private
        onFieldDisable: PHP missing
        setAlignment: MISMATCH
            return: JS missing
            visibility: MISMATCH
              JS: :private
              PHP: :protected
        setErrors: PHP missing
        setNotices: PHP missing
        updateMessages: PHP missing
    Properties:
        align: JS missing
        errors: JS missing
        fieldWidget: JS missing
        help: JS missing
        notices: JS missing

FieldsetLayout: JS/PHP
    Basic:
        description: MISMATCH
          JS: "FieldsetLayouts are composed of one or more {@link FieldLayout FieldLayouts}, which each contain an individual widget and, optionally, a label. Each Fieldset can be configured with a label as well. For more information and examples, please see the [OOjs UI documentation on MediaWiki][1]. @example // Example of a fieldset layout var input1 = new OO.ui.TextInputWidget( { placeholder: 'A text input field' } ); var input2 = new OO.ui.TextInputWidget( { placeholder: 'A text input field' } ); var fieldset = new OO.ui.FieldsetLayout( { label: 'Example of a fieldset layout' } ); fieldset.addItems( [ new OO.ui.FieldLayout( input1, { label: 'Field One' } ), new OO.ui.FieldLayout( input2, { label: 'Field Two' } ) ] ); $( 'body' ).append( fieldset.$element ); [1]: https://www.mediawiki.org/wiki/OOjs_UI/Layouts/Fields_and_Fieldsets"
          PHP: "Layout made of a fieldset and optional legend. Just add FieldLayout items."
    Methods:
        #constructor: MISMATCH
            config: MISMATCH
                $overlay: PHP missing
                help: PHP missing
                items: MISMATCH
                    description: MISMATCH
                      JS: "An array of fields to add to the fieldset. See FieldLayout for more information about fields."
                      PHP: "Items to add"

FlaggedElement: JS/PHP
    Basic:
        description: MISMATCH
          JS: "The FlaggedElement class is an attribute mixin, meaning that it is used to add additional functionality to an element created by another class. The class provides a \u2018flags\u2019 property assigned the name (or an array of names) of styling flags, which are used to customize the look and feel of a widget to better describe its importance and functionality. The library currently contains the following styling flags for general use: - **progressive**: Progressive styling is applied to convey that the widget will move the user forward in a process. - **destructive**: Destructive styling is applied to convey that the widget will remove something. - **constructive**: Constructive styling is applied to convey that the widget will create something. The flags affect the appearance of the buttons: @example // FlaggedElement is mixed into ButtonWidget to provide styling flags var button1 = new ButtonWidget( { label: 'Constructive', flags: 'constructive' } ); var button2 = new OO.ui.ButtonWidget( { label: 'Destructive', flags: 'destructive' } ); var button3 = new OO.ui.ButtonWidget( { label: 'Progressive', flags: 'progressive' } ); $( 'body' ).append( button1.$element, button2.$element, button3.$element ); {@link OO.ui.ActionWidget ActionWidgets}, which are a special kind of button that execute an action, use these flags: **primary** and **safe**. Please see the [OOjs UI documentation on MediaWiki] [1] for more information. [1]: https://www.mediawiki.org/wiki/OOjs_UI/Elements/Flagged"
          PHP: "Element with named flags that can be added, removed, listed and checked. A flag, when set, adds a CSS class on the `$element` by combining `oo-ui-flaggedElement-` with the flag name. Flags are primarily useful for styling."
    Methods:
        #constructor: PHP missing
        clearFlags: MISMATCH
            return: JS missing
        hasFlag: MISMATCH
            description: MISMATCH
              JS: "Check if the specified flag is set."
              PHP: "Check if a flag is set."
            return: MISMATCH
                description: MISMATCH
                  JS: "The flag is set"
                  PHP: "Has flag"
        initializeFlaggedElement: JS missing
        setFlaggedElement: PHP missing
        setFlags: MISMATCH
            params: MISMATCH
                flags: MISMATCH
                    description: MISMATCH
                      JS: "A flag name, an array of flag names, or an array keyed by flag name with a boolean value that indicates whether the flag should be added (`true`) or removed (`false`)."
                      PHP: "One or more flags to add, or an array keyed by flag name containing boolean set/remove instructions."
                    type: MISMATCH
                      JS: "string|string[]|array"
                      PHP: "string|array"
            return: JS missing
    Properties:
        flagged: JS missing
        flags: JS missing

FormLayout: JS/PHP
    Basic:
        description: MISMATCH
          JS: "FormLayouts are used to wrap {@link FieldsetLayout FieldsetLayouts} when you intend to use browser-based form submission for the fields instead of handling them in JavaScript. Form layouts can be configured with an HTML form action, an encoding type, and a method using the action(), enctype(), and method() configs, respectively. See the [OOjs UI documentation on MediaWiki] [1] for more information and examples. Only widgets from the {@link OO.ui.InputWidget InputWidget} family support form submission. It includes standard form elements like {@link OO.ui.CheckboxInputWidget checkboxes}, {@link OO.ui.RadioInputWidget radio buttons} and {@link OO.ui.TextInputWidget text fields}, as well as some fancier controls. Some controls have both regular and InputWidget variants, for example OO.ui.DropdownWidget and OO.ui.DropdownInputWidget \u2013 only the latter support form submission and often have simplified APIs to match the capabilities of HTML forms. See the [OOjs UI Inputs documentation on MediaWiki] [2] for more information about InputWidgets. [1]: https://www.mediawiki.org/wiki/OOjs_UI/Layouts/Forms [2]: https://www.mediawiki.org/wiki/OOjs_UI/Widgets/Inputs @example // Example of a form layout that wraps a fieldset layout var input1 = new OO.ui.TextInputWidget( { placeholder: 'Username' } ); var input2 = new OO.ui.TextInputWidget( { placeholder: 'Password', type: 'password' } ); var submit = new OO.ui.ButtonInputWidget( { label: 'Submit' } ); var fieldset = new OO.ui.FieldsetLayout( { label: 'A form layout' } ); fieldset.addItems( [ new OO.ui.FieldLayout( input1, { label: 'Username', align: 'top' } ), new OO.ui.FieldLayout( input2, { label: 'Password', align: 'top' } ), new OO.ui.FieldLayout( submit ) ] ); var form = new OO.ui.FormLayout( { items: [ fieldset ], action: '/api/formhandler', method: 'get' } ) $( 'body' ).append( form.$element );"
          PHP: "Layout with an HTML form."
    Methods:
        #constructor: MISMATCH
            config: MISMATCH
                items: MISMATCH
                    description: MISMATCH
                      JS: "Fieldset layouts to add to the form layout."
                      PHP: "Items to add"
        onFormSubmit: PHP missing

GroupElement: JS/PHP
    Basic:
        description: MISMATCH
          JS: "Any OOjs UI widget that contains other widgets (such as {@link ButtonWidget buttons} or {@link OO.ui.OptionWidget options}) mixes in GroupElement. Adding, removing, and clearing items from the group is done through the interface the class provides. For more information, please see the [OOjs UI documentation on MediaWiki] [1]. [1]: https://www.mediawiki.org/wiki/OOjs_UI/Elements/Groups"
          PHP: "Element containing a sequence of child elements."
        mixins: MISMATCH
          JS: ["OO.EmitterList"]
          PHP: {}
    Methods:
        #constructor: PHP missing
        addItems: MISMATCH
            description: MISMATCH
              JS: "Add items to the group. Items will be added to the end of the group array unless the optional `index` parameter specifies a different insertion point. Adding an existing item will move it to the end of the array or the point specified by the `index`."
              PHP: "Add items. Adding an existing item will move it."
            params: MISMATCH
                index: MISMATCH
                    description: MISMATCH
                      JS: "Index of the insertion point"
                      PHP: "Index to insert items at"
                items: MISMATCH
                    description: MISMATCH
                      JS: "An array of items to add to the group"
                      PHP: "Items"
            return: JS missing
        clearItems: MISMATCH
            description: MISMATCH
              JS: "Clear all items from the group. Cleared items are detached from the DOM, not removed, so that they may be reused. To remove only a subset of items from a group, use the removeItems() method."
              PHP: "Clear all items. Items will be detached, not removed, so they can be used later."
            return: JS missing
        getItemFromData: PHP missing
        getItems: JS missing
        getItemsFromData: PHP missing
        initializeGroupElement: JS missing
        insertItemElements: PHP missing
        isEmpty: JS missing
        removeItems: MISMATCH
            description: MISMATCH
              JS: "Remove the specified items from a group. Removed items are detached (not removed) from the DOM so that they may be reused. To remove all items from a group, you may wish to use the clearItems() method instead."
              PHP: "Remove items."
            params: MISMATCH
                items: MISMATCH
                    description: MISMATCH
                      JS: "An array of items to remove"
                      PHP: "Items to remove"
            return: JS missing
        setGroupElement: PHP missing
    Properties:
        group: JS missing
        items: JS missing

HorizontalLayout: JS/PHP
    Basic:
        description: MISMATCH
          JS: "HorizontalLayout arranges its contents in a single line (using `display: inline-block` for its items), with small margins between them. Convenient when you need to put a number of block-level widgets on a single line next to each other. Note that inline elements, such as ButtonWidgets, do not need this wrapper. @example // HorizontalLayout with a text input and a label var layout = new OO.ui.HorizontalLayout( { items: [ new OO.ui.LabelWidget( { label: 'Label' } ), new OO.ui.TextInputWidget( { value: 'Text' } ) ] } ); $( 'body' ).append( layout.$element );"
          PHP: "HorizontalLayout arranges its contents in a single line (using `display: inline-block` for its items), with small margins between them."

HtmlSnippet: JS/PHP
    Basic:
        description: MISMATCH
          JS: "Wraps an HTML snippet for use with configuration values which default to strings. This bypasses the default html-escaping done to string values."
          PHP: "Wraps a HTML snippet for use with Tag::appendContent() and Tag::prependContent()."
    Methods:
        #constructor: MISMATCH
            params: MISMATCH
                content: MISMATCH
                    description: MISMATCH
                      JS: "HTML content"
                      PHP: ""
        __toString: JS missing
        toString: PHP missing
    Properties:
        content: JS missing

IconElement: JS/PHP
    Basic:
        description: MISMATCH
          JS: "IconElement is often mixed into other classes to generate an icon. Icons are graphics, about the size of normal text. They are used to aid the user in locating a control or to convey information in a space-efficient way. See the [OOjs UI documentation on MediaWiki] [1] for a list of icons included in the library. [1]: https://www.mediawiki.org/wiki/OOjs_UI/Widgets/Icons,_Indicators,_and_LabelsIcons()"
          PHP: "Element containing an icon. Icons are graphics, about the size of normal text. They can be used to aid the user in locating a control or convey information in a more space efficient way. Icons should rarely be used without labels; such as in a toolbar where space is at a premium or within a context where the meaning is very clear to the user."
    Methods:
        #constructor: PHP missing
        getIcon: MISMATCH
            description: MISMATCH
              JS: "Get the symbolic name of the icon."
              PHP: "Get icon name."
        getIconElement: JS missing
        getIconTitle: PHP missing
        initializeIconElement: JS missing
        setIcon: MISMATCH
            description: MISMATCH
              JS: "Set icon by symbolic name (e.g., \u2018remove\u2019 or \u2018menu\u2019). Use `null` to remove an icon. The icon parameter can also be set to a map of icon names. See the icon() config setting for an example."
              PHP: "Set icon name."
            params: MISMATCH
                icon: MISMATCH
                    description: MISMATCH
                      JS: "A symbolic icon name, a {@link icon() map of icon names} keyed by language code, or `null` to remove the icon."
                      PHP: "Symbolic icon name"
                    type: MISMATCH
                      JS: "Object|string|null"
                      PHP: "string|null"
            return: JS missing
        setIconElement: PHP missing
        setIconTitle: PHP missing
    Properties:
        icon: MISMATCH
            description: MISMATCH
              JS: "The symbolic name of the icon (e.g., \u2018remove\u2019 or \u2018menu\u2019), or a map of symbolic names. A map is used for i18n purposes and contains a `default` icon name and additional names keyed by language code. The `default` name is used when no icon is keyed by the user's language. Example of an i18n map: { default: 'bold-a', en: 'bold-b', de: 'bold-f' } Note: the static property will be overridden if the icon() configuration is used."
              PHP: ""
            static: PHP missing
            type: MISMATCH
              JS: "Object|string"
              PHP: "Tag"
        iconName: JS missing
        iconTitle: PHP missing

IconWidget: JS/PHP
    Basic:
        description: MISMATCH
          JS: "IconWidget is a generic widget for {@link IconElement icons}. In general, IconWidgets should be used with OO.ui.LabelWidget, which creates a label that identifies the icon\u2019s function. See the [OOjs UI documentation on MediaWiki] [1] for a list of icons included in the library. @example // An icon widget with a label var myIcon = new OO.ui.IconWidget( { icon: 'help', iconTitle: 'Help' } ); // Create a label. var iconLabel = new OO.ui.LabelWidget( { label: 'Help' } ); $( 'body' ).append( myIcon.$element, iconLabel.$element ); [1]: https://www.mediawiki.org/wiki/OOjs_UI/Widgets/Icons,_Indicators,_and_LabelsIcons()"
          PHP: "Icon widget. See IconElement for more information."

IndicatorElement: JS/PHP
    Basic:
        description: MISMATCH
          JS: "IndicatorElement is often mixed into other classes to generate an indicator. Indicators are small graphics that are generally used in two ways: - To draw attention to the status of an item. For example, an indicator might be used to show that an item in a list has errors that need to be resolved. - To clarify the function of a control that acts in an exceptional way (a button that opens a menu instead of performing an action directly, for example). For a list of indicators included in the library, please see the [OOjs UI documentation on MediaWiki] [1]. [1]: https://www.mediawiki.org/wiki/OOjs_UI/Widgets/Icons,_Indicators,_and_LabelsIndicators()"
          PHP: "Element containing an indicator. Indicators are graphics, smaller than normal text. They can be used to describe unique status or behavior. Indicators should only be used in exceptional cases; such as a button that opens a menu instead of performing an action directly, or an item in a list which has errors that need to be resolved."
    Methods:
        #constructor: PHP missing
        getIndicator: MISMATCH
            description: MISMATCH
              JS: "Get the symbolic name of the indicator (e.g., \u2018alert\u2019 or \u2018down\u2019)."
              PHP: "Get indicator name."
        getIndicatorElement: JS missing
        getIndicatorTitle: PHP missing
        initializeIndicatorElement: JS missing
        setIndicator: MISMATCH
            description: MISMATCH
              JS: "Set the indicator by its symbolic name: \u2018alert\u2019, \u2018down\u2019, \u2018next\u2019, \u2018previous\u2019, \u2018required\u2019, \u2018up\u2019. Use `null` to remove the indicator."
              PHP: "Set indicator name."
            params: MISMATCH
                indicator: MISMATCH
                    description: MISMATCH
                      JS: "Symbolic name of indicator, or `null` for no indicator"
                      PHP: "Symbolic name of indicator to use or null for no indicator"
            return: JS missing
        setIndicatorElement: PHP missing
        setIndicatorTitle: PHP missing
    Properties:
        indicator: MISMATCH
            description: MISMATCH
              JS: "Symbolic name of the indicator (e.g., \u2018alert\u2019 or \u2018down\u2019). The static property will be overridden if the indicator() configuration is used."
              PHP: ""
            static: PHP missing
            type: MISMATCH
              JS: "string|null"
              PHP: "Tag"
        indicatorName: JS missing
        indicatorTitle: PHP missing

IndicatorWidget: JS/PHP
    Basic:
        description: MISMATCH
          JS: "IndicatorWidgets create indicators, which are small graphics that are generally used to draw attention to the status of an item or to clarify the function of a control. For a list of indicators included in the library, please see the [OOjs UI documentation on MediaWiki][1]. @example // Example of an indicator widget var indicator1 = new IndicatorWidget( { indicator: 'alert' } ); // Create a fieldset layout to add a label var fieldset = new OO.ui.FieldsetLayout(); fieldset.addItems( [ new OO.ui.FieldLayout( indicator1, { label: 'An alert indicator:' } ) ] ); $( 'body' ).append( fieldset.$element ); [1]: https://www.mediawiki.org/wiki/OOjs_UI/Widgets/Icons,_Indicators,_and_LabelsIndicators()"
          PHP: "Indicator widget. See IndicatorElement for more information."

InputWidget: JS/PHP
    Basic:
        description: MISMATCH
          JS: "InputWidget is the base class for all input widgets, which include {@link TextInputWidget text inputs}, {@link OO.ui.CheckboxInputWidget checkbox inputs}, {@link OO.ui.RadioInputWidget radio inputs}, and {@link OO.ui.ButtonInputWidget button inputs}. See the [OOjs UI documentation on MediaWiki] [1] for more information and examples. [1]: https://www.mediawiki.org/wiki/OOjs_UI/Widgets/Inputs"
          PHP: "Base class for input widgets."
    Methods:
        #constructor: MISMATCH
            config: MISMATCH
                dir: MISMATCH
                    description: MISMATCH
                      JS: "The directionality of the input (ltr/rtl)."
                      PHP: "The directionality of the input (ltr/rtl)"
                inputFilter: PHP missing
                name: MISMATCH
                    description: MISMATCH
                      JS: "The value of the input\u2019s HTML `name` attribute."
                      PHP: "HTML input name"
                value: MISMATCH
                    description: MISMATCH
                      JS: "The value of the input."
                      PHP: "Input value"
        blur: PHP missing
        cleanUpValue: MISMATCH
            visibility: MISMATCH
              JS: :private
              PHP: :protected
        focus: PHP missing
        getInputElement: MISMATCH
            description: MISMATCH
              JS: "Get input element. Subclasses of InputWidget use the `config` parameter to produce different elements in different circumstances. The element must have a `value` property (like form elements)."
              PHP: "Get input element."
        getInputId: MISMATCH
            return: MISMATCH
                type: MISMATCH
                  JS: "string"
                  PHP: "{string}"
        onEdit: PHP missing
        setDir: MISMATCH
            return: JS missing
        setValue: MISMATCH
            return: JS missing
        simulateLabelClick: PHP missing
    Properties:
        input: JS missing
        value: JS missing

LabelElement: JS/PHP
    Basic:
        description: MISMATCH
          JS: "LabelElement is often mixed into other classes to generate a label, which helps identify the function of an interface element. See the [OOjs UI documentation on MediaWiki] [1] for more information. [1]: https://www.mediawiki.org/wiki/OOjs_UI/Widgets/Icons,_Indicators,_and_LabelsLabels()"
          PHP: "Element containing a label."
    Methods:
        #constructor: PHP missing
        getLabel: MISMATCH
            return: MISMATCH
                description: MISMATCH
                  JS: "Label nodes; text; a function that returns nodes or text; or null for no label"
                  PHP: "Label text"
                type: MISMATCH
                  JS: "string|null"
                  PHP: "string|HtmlSnippet|null"
        initializeLabelElement: JS missing
        setHighlightedQuery: PHP missing
        setLabel: MISMATCH
            params: MISMATCH
                label: MISMATCH
                    description: MISMATCH
                      JS: "Label nodes; text; a function that returns nodes or text; or null for no label"
                      PHP: "Label text"
                    type: MISMATCH
                      JS: "Tag|string|HtmlSnippet|Function|null"
                      PHP: "string|HtmlSnippet|null"
            return: JS missing
        setLabelContent: PHP missing
        setLabelElement: PHP missing
    Properties:
        highlightQuery: PHP missing
        label: MISMATCH
            description: MISMATCH
              JS: "The label text. The label can be specified as a plaintext string, a function that will produce a string in the future, or `null` for no label. The static value will be overridden if a label is specified with the label() config option."
              PHP: ""
            static: PHP missing
            type: MISMATCH
              JS: "string|null"
              PHP: "Tag"
        labelValue: JS missing

LabelWidget: JS/PHP
    Basic:
        description: MISMATCH
          JS: "LabelWidgets help identify the function of interface elements. Each LabelWidget can be configured with a `label` option that is set to a string, a label node, or a function: - String: a plaintext string - Tag selection: a Tag selection, used for anything other than a plaintext label, e.g., a label that includes a link or special styling, such as a gray color or additional graphical elements. - Function: a function that will produce a string in the future. Functions are used in cases where the value of the label is not currently defined. In addition, the LabelWidget can be associated with an {@link InputWidget input widget}, which will come into focus when the label is clicked. @example // Examples of LabelWidgets var label1 = new OO.ui.LabelWidget( { label: 'plaintext label' } ); var label2 = new OO.ui.LabelWidget( { label: $( '<a href=\"default.html\">Tag label</a>' ) } ); // Create a fieldset layout with fields for each example var fieldset = new OO.ui.FieldsetLayout(); fieldset.addItems( [ new OO.ui.FieldLayout( label1 ), new OO.ui.FieldLayout( label2 ) ] ); $( 'body' ).append( fieldset.$element );"
          PHP: "Label widget."
        mixins: MISMATCH
          JS: ["LabelElement", "TitledElement"]
          PHP: ["LabelElement"]
    Methods:
        #constructor: MISMATCH
            config: MISMATCH
                input: MISMATCH
                    description: MISMATCH
                      JS: "{@link InputWidget Input widget} that uses the label. Clicking the label will focus the specified input field."
                      PHP: "Input widget this label is for"
    Properties:
        input: JS missing

Layout: JS/PHP
    Basic:
        description: MISMATCH
          JS: "Layouts are containers for elements and are used to arrange other widgets of arbitrary type in a way that is centrally controlled and can be updated dynamically. Layouts can be, and usually are, combined. See {@link FieldsetLayout FieldsetLayout}, {@link OO.ui.FieldLayout FieldLayout}, {@link OO.ui.FormLayout FormLayout}, {@link OO.ui.PanelLayout PanelLayout}, {@link OO.ui.StackLayout StackLayout}, {@link OO.ui.PageLayout PageLayout}, {@link OO.ui.HorizontalLayout HorizontalLayout}, and {@link OO.ui.BookletLayout BookletLayout} for more information and examples."
          PHP: "Container for elements."

MediaWikiTheme: JS/PHP
    Methods:
        #constructor: PHP missing

PanelLayout: JS/PHP
    Basic:
        description: MISMATCH
          JS: "PanelLayouts expand to cover the entire area of their parent. They can be configured with scrolling, padding, and a frame, and are often used together with {@link StackLayout StackLayouts}. @example // Example of a panel layout var panel = new OO.ui.PanelLayout( { expanded: false, framed: true, padded: true, $content: $( '<p>A panel layout with padding and a frame.</p>' ) } ); $( 'body' ).append( panel.$element );"
          PHP: "Layout that expands to cover the entire area of its parent, with optional scrolling and padding."
    Methods:
        #constructor: MISMATCH
            config: MISMATCH
                expanded: MISMATCH
                    description: MISMATCH
                      JS: "Expand the panel to fill the entire parent element."
                      PHP: "Expand size to fill the entire parent element"
                framed: MISMATCH
                    description: MISMATCH
                      JS: "Render the panel with a frame to visually separate it from outside content."
                      PHP: "Wrap in a frame to visually separate from outside content"
                padded: MISMATCH
                    description: MISMATCH
                      JS: "Add padding between the content and the edges of the panel."
                      PHP: "Pad the content from the edges"
        focus: PHP missing

ProgressBarWidget: JS/PHP
    Basic:
        description: MISMATCH
          JS: "Progress bars visually display the status of an operation, such as a download, and can be either determinate or indeterminate: - **determinate** process bars show the percent of an operation that is complete. - **indeterminate** process bars use a visual display of motion to indicate that an operation is taking place. Because the extent of an indeterminate operation is unknown, the bar does not use percentages. The value of the `progress` configuration determines whether the bar is determinate or indeterminate. @example // Examples of determinate and indeterminate progress bars. var progressBar1 = new ProgressBarWidget( { progress: 33 } ); var progressBar2 = new OO.ui.ProgressBarWidget(); // Create a FieldsetLayout to layout progress bars var fieldset = new OO.ui.FieldsetLayout; fieldset.addItems( [ new OO.ui.FieldLayout( progressBar1, {label: 'Determinate', align: 'top'}), new OO.ui.FieldLayout( progressBar2, {label: 'Indeterminate', align: 'top'}) ] ); $( 'body' ).append( fieldset.$element );"
          PHP: ""
    Methods:
        #constructor: MISMATCH
            config: MISMATCH
                progress: MISMATCH
                    default: PHP missing
                    description: MISMATCH
                      JS: "The type of progress bar (determinate or indeterminate). To create a determinate progress bar, specify a number that reflects the initial percent complete. By default, the progress bar is indeterminate."
                      PHP: "The type of progress bar (determinate or indeterminate). To create a determinate progress bar,specify a number that reflects the initial percent complete. By default, the progress bar is indeterminate."
                    type: MISMATCH
                      JS: "number|boolean"
                      PHP: "bool|int"
        getProgress: MISMATCH
            description: MISMATCH
              JS: "Get the percent of the progress that has been completed. Indeterminate progresses will return `false`."
              PHP: ""
            return: MISMATCH
                description: MISMATCH
                  JS: "Progress percent"
                  PHP: ""
                type: MISMATCH
                  JS: "number|boolean"
                  PHP: "bool|int"
        setProgress: MISMATCH
            description: MISMATCH
              JS: "Set the percent of the process completed or `false` for an indeterminate process."
              PHP: ""
            params: MISMATCH
                progress: MISMATCH
                    description: MISMATCH
                      JS: "Progress percent or `false` for indeterminate"
                      PHP: ""
                    type: MISMATCH
                      JS: "number|boolean"
                      PHP: "bool|int"
    Properties:
        bar: JS missing
        progress: JS missing

RadioInputWidget: JS/PHP
    Basic:
        description: MISMATCH
          JS: "RadioInputWidget creates a single radio button. Because radio buttons are usually used as a set, in most cases you will want to use a {@link RadioSelectWidget radio select} with {@link OO.ui.RadioOptionWidget radio options} instead of this class. For more information, please see the [OOjs UI documentation on MediaWiki][1]. This widget can be used inside an HTML form, such as a OO.ui.FormLayout. @example // An example of selected, unselected, and disabled radio inputs var radio1 = new OO.ui.RadioInputWidget( { value: 'a', selected: true } ); var radio2 = new OO.ui.RadioInputWidget( { value: 'b' } ); var radio3 = new OO.ui.RadioInputWidget( { value: 'c', disabled: true } ); // Create a fieldset layout with fields for each radio button. var fieldset = new OO.ui.FieldsetLayout( { label: 'Radio inputs' } ); fieldset.addItems( [ new OO.ui.FieldLayout( radio1, { label: 'Selected', align: 'inline' } ), new OO.ui.FieldLayout( radio2, { label: 'Unselected', align: 'inline' } ), new OO.ui.FieldLayout( radio3, { label: 'Disabled', align: 'inline' } ), ] ); $( 'body' ).append( fieldset.$element ); [1]: https://www.mediawiki.org/wiki/OOjs_UI/Widgets/Inputs"
          PHP: "Radio input widget."
        mixins: MISMATCH
          JS: ["a"]
          PHP: {}
    Methods:
        #constructor: MISMATCH
            config: MISMATCH
                selected: MISMATCH
                    description: MISMATCH
                      JS: "Select the radio button initially. By default, the radio button is not selected."
                      PHP: "Whether the radio button is initially selected"
        setSelected: MISMATCH
            params: MISMATCH
                state: MISMATCH
                    description: MISMATCH
                      JS: "`true` for selected"
                      PHP: "Whether the button is selected"
            return: JS missing

RadioSelectInputWidget: JS/PHP
    Basic:
        description: MISMATCH
          JS: "RadioSelectInputWidget is a {@link RadioSelectWidget RadioSelectWidget} intended to be used within an HTML form, such as a OO.ui.FormLayout. The selected value is synchronized with the value of a hidden HTML `input` tag. Please see the [OOjs UI documentation on MediaWiki][1] for more information about input widgets. This and OO.ui.DropdownInputWidget support the same configuration options. @example // Example: A RadioSelectInputWidget with three options var radioSelectInput = new OO.ui.RadioSelectInputWidget( { options: [ { data: 'a', label: 'First' }, { data: 'b', label: 'Second'}, { data: 'c', label: 'Third' } ] } ); $( 'body' ).append( radioSelectInput.$element ); [1]: https://www.mediawiki.org/wiki/OOjs_UI/Widgets/Inputs"
          PHP: "Multiple radio buttons input widget. Intended to be used within a FormLayout."
    Methods:
        #constructor: MISMATCH
            config: MISMATCH
                options: MISMATCH
                    default: PHP missing
                    description: MISMATCH
                      JS: "Array of menu options in the format `{ data: \u2026, label: \u2026 }`"
                      PHP: "Array of menu options in the format `[ 'data' => \u2026, 'label' => \u2026 ]`"
                    type: MISMATCH
                      JS: "Object[]"
                      PHP: "array[]"
        onMenuSelect: PHP missing
        setOptions: MISMATCH
            params: MISMATCH
                options: MISMATCH
                    description: MISMATCH
                      JS: "Array of menu options in the format `{ data: \u2026, label: \u2026 }`"
                      PHP: "Array of menu options in the format `[ 'data' => \u2026, 'label' => \u2026 ]`"
                    type: MISMATCH
                      JS: "Object[]"
                      PHP: "array[]"
            return: JS missing
    Properties:
        fields: JS missing
        name: JS missing

TabIndexedElement: JS/PHP
    Basic:
        description: MISMATCH
          JS: "The TabIndexedElement class is an attribute mixin used to add additional functionality to an element created by another class. The mixin provides a \u2018tabIndex\u2019 property, which specifies the order in which users will navigate through the focusable elements via the \"tab\" key. @example // TabIndexedElement is mixed into the ButtonWidget class // to provide a tabIndex property. var button1 = new ButtonWidget( { label: 'fourth', tabIndex: 4 } ); var button2 = new OO.ui.ButtonWidget( { label: 'second', tabIndex: 2 } ); var button3 = new OO.ui.ButtonWidget( { label: 'third', tabIndex: 3 } ); var button4 = new OO.ui.ButtonWidget( { label: 'first', tabIndex: 1 } ); $( 'body' ).append( button1.$element, button2.$element, button3.$element, button4.$element );"
          PHP: "Element supporting \"sequential focus navigation\" using the 'tabindex' attribute."
    Methods:
        #constructor: PHP missing
        getTabIndex: MISMATCH
            description: MISMATCH
              JS: "Get the value of the tabindex."
              PHP: "Get tab index value."
            return: MISMATCH
                description: MISMATCH
                  JS: "Tabindex value"
                  PHP: "Tab index value"
        initializeTabIndexedElement: JS missing
        onTabIndexedElementDisable: PHP missing
        setTabIndex: MISMATCH
            description: MISMATCH
              JS: "Set the value of the tabindex."
              PHP: "Set tab index value."
            params: MISMATCH
                tabIndex: MISMATCH
                    description: MISMATCH
                      JS: "Tabindex value, or `null` for no tabindex"
                      PHP: "Tab index value or null for no tab index"
            return: JS missing
        setTabIndexedElement: PHP missing
        updateTabIndex: MISMATCH
            description: MISMATCH
              JS: "Update the `tabindex` attribute, in case of changes to tab index or disabled state."
              PHP: "Update the tabIndex attribute, in case of changes to tabIndex or disabled state."
            return: JS missing
            visibility: MISMATCH
              JS: :private
              PHP: :public
    Properties:
        tabIndex: JS missing
        tabIndexed: JS missing

TextInputWidget: JS/PHP
    Basic:
        description: MISMATCH
          JS: "TextInputWidgets, like HTML text inputs, can be configured with options that customize the size of the field as well as its presentation. In addition, these widgets can be configured with {@link IconElement icons}, {@link OO.ui.mixin.IndicatorElement indicators}, an optional validation-pattern (used to determine if an input value is valid or not) and an input filter, which modifies incoming values rather than validating them. Please see the [OOjs UI documentation on MediaWiki] [1] for more information and examples. This widget can be used inside an HTML form, such as a OO.ui.FormLayout. @example // Example of a text input widget var textInput = new OO.ui.TextInputWidget( { value: 'Text input' } ) $( 'body' ).append( textInput.$element ); [1]: https://www.mediawiki.org/wiki/OOjs_UI/Widgets/Inputs"
          PHP: "Input widget with a text field."
        mixins: MISMATCH
          JS: ["IconElement", "IndicatorElement", "LabelElement"]
          PHP: ["IconElement", "IndicatorElement"]
    Methods:
        #constructor: MISMATCH
            config: MISMATCH
                autocomplete: MISMATCH
                    description: MISMATCH
                      JS: "Should the browser support autocomplete for this field"
                      PHP: "If the field should support autocomplete or not"
                autofocus: MISMATCH
                    description: MISMATCH
                      JS: "Use an HTML `autofocus` attribute to instruct the browser to focus this widget."
                      PHP: "Ask the browser to focus this widget, using the 'autofocus' HTML attribute"
                autosize: PHP missing
                labelPosition: PHP missing
                maxLength: MISMATCH
                    description: MISMATCH
                      JS: "Maximum number of characters allowed in the input."
                      PHP: "Maximum allowed number of characters to input"
                maxRows: PHP missing
                readOnly: MISMATCH
                    description: MISMATCH
                      JS: "Prevent changes to the value of the text input."
                      PHP: "Prevent changes"
                rows: MISMATCH
                    description: MISMATCH
                      JS: "If multiline, number of visible lines in textarea. If used with `autosize`, specifies minimum number of rows to display."
                      PHP: "If multiline, number of visible lines in textarea"
                    type: MISMATCH
                      JS: "number"
                      PHP: "int"
                type: MISMATCH
                    description: MISMATCH
                      JS: "The value of the HTML `type` attribute: 'text', 'password', 'search', 'email', 'url' or 'number'. Ignored if `multiline` is true. Some values of `type` result in additional behaviors: - `search`: implies `icon: 'search'` and `indicator: 'clear'`; when clicked, the indicator empties the text field"
                      PHP: "HTML tag `type` attribute: 'text', 'password', 'search', 'email', 'url' or 'number'. Ignored if `multiline` is true. Some values of `type` result in additional behaviors: - `search`: implies `icon: 'search'` and `indicator: 'clear'`; when clicked, the indicator empties the text field"
                validate: PHP missing
        adjustSize: PHP missing
        encapsulateContent: PHP missing
        getInputLength: PHP missing
        getRange: PHP missing
        getSaneType: PHP missing
        getValidity: PHP missing
        insertContent: PHP missing
        installParentChangeDetector: PHP missing
        isAutosizing: PHP missing
        isMultiline: MISMATCH
            description: MISMATCH
              JS: "Check if the input supports multiple lines."
              PHP: "Check if input supports multiple lines."
        isReadOnly: MISMATCH
            description: MISMATCH
              JS: "Check if the input is {@link readOnly() read-only}."
              PHP: "Check if the widget is read-only."
        isRequired: MISMATCH
            description: MISMATCH
              JS: "Check if the input is {@link required() required}."
              PHP: "Check if the widget is required."
        moveCursorToEnd: PHP missing
        moveCursorToStart: PHP missing
        onBlur: PHP missing
        onChange: PHP missing
        onDebouncedChange: PHP missing
        onDisable: PHP missing
        onElementAttach: PHP missing
        onFocus: PHP missing
        onIconMouseDown: PHP missing
        onIndicatorMouseDown: PHP missing
        onKeyPress: PHP missing
        positionLabel: PHP missing
        select: PHP missing
        selectRange: PHP missing
        setLabelPosition: PHP missing
        setReadOnly: MISMATCH
            description: MISMATCH
              JS: "Set the {@link readOnly() read-only} state of the input."
              PHP: "Set the read-only state of the widget. This should probably change the widget's appearance and prevent it from being used."
            return: JS missing
        setRequired: MISMATCH
            description: MISMATCH
              JS: "Set the {@link required() required} state of the input."
              PHP: "Set the required state of the widget."
            return: JS missing
        setValidation: PHP missing
        setValidityFlag: PHP missing
        updatePosition: PHP missing
        updateSearchIndicator: PHP missing
    Properties:
        multiline: JS missing
        readOnly: JS missing
        required: JS missing
        type: JS missing

Theme: JS/PHP
    Methods:
        #constructor: PHP missing
        getDialogTransitionDuration: PHP missing
        queueUpdateElementClasses: PHP missing
        setSingleton: JS missing
        singleton: JS missing
        updateElementClasses: MISMATCH
            return: JS missing
        updateQueuedElementClasses: PHP missing

TitledElement: JS/PHP
    Basic:
        description: MISMATCH
          JS: "TitledElement is mixed into other classes to provide a `title` attribute. Titles are rendered by the browser and are made visible when the user moves the mouse over the element. Titles are not visible on touch devices. @example // TitledElement provides a 'title' attribute to the // ButtonWidget class var button = new ButtonWidget( { label: 'Button with Title', title: 'I am a button' } ); $( 'body' ).append( button.$element );"
          PHP: "Element with a title. Titles are rendered by the browser and are made visible when hovering the element. Titles are not visible on touch devices."
    Methods:
        #constructor: PHP missing
        initializeTitledElement: JS missing
        setTitle: MISMATCH
            params: MISMATCH
                title: MISMATCH
                    description: MISMATCH
                      JS: "Title text, a function that returns text, or `null` for no title"
                      PHP: "Title text or null for no title"
            return: JS missing
        setTitledElement: PHP missing
    Properties:
        title: MISMATCH
            description: MISMATCH
              JS: "The title text, a function that returns text, or `null` for no title. The value of the static property is overridden if the title() config option is used."
              PHP: "Title text."
            static: PHP missing
            type: MISMATCH
              JS: "string|null"
              PHP: "string"
        titled: JS missing

Widget: JS/PHP
    Basic:
        description: MISMATCH
          JS: "Widgets are compositions of one or more OOjs UI elements that users can both view and interact with. All widgets can be configured and modified via a standard API, and their state can change dynamically according to a model."
          PHP: "User interface control."
    Methods:
        #constructor: MISMATCH
            config: MISMATCH
                disabled: MISMATCH
                    description: MISMATCH
                      JS: "Disable the widget. Disabled widgets cannot be used and their appearance reflects this state."
                      PHP: "Disable"
        isDisabled: MISMATCH
            return: MISMATCH
                description: MISMATCH
                  JS: "Widget is disabled"
                  PHP: "Button is disabled"
        setDisabled: MISMATCH
            description: MISMATCH
              JS: "Set the 'disabled' state of the widget. When a widget is disabled, it cannot be used and its appearance is updated to reflect this state."
              PHP: "Set the disabled state of the widget. This should probably change the widgets' appearance and prevent it from being used."
            return: JS missing
        updateDisabled: PHP missing
    Properties:
        disabled: JS missing
        supportsSimpleLabel: MISMATCH
            description: MISMATCH
              JS: "Whether this widget will behave reasonably when wrapped in an HTML `<label>`. If this is true, wrappers such as FieldLayout may use a `<label>` instead of implementing own label click handling."
              PHP: "Whether this widget will behave reasonably when wrapped in a HTML `<label>`. If this is true, wrappers such as FieldLayout may use a `<label>`."