@types/react-bootstrap

  • Version 0.32.25
  • Published
  • 68.6 kB
  • 1 dependency
  • MIT license

Install

npm i @types/react-bootstrap
yarn add @types/react-bootstrap
pnpm add @types/react-bootstrap

Overview

TypeScript definitions for react-bootstrap

Index

Interfaces

Type Aliases

Namespaces

Interfaces

interface AccordionProps

interface AccordionProps extends React.HTMLProps<Accordion> {}

    property bsSize

    bsSize?: Sizes;

      property bsStyle

      bsStyle?: string;

        property collapsible

        collapsible?: boolean;

          property defaultExpanded

          defaultExpanded?: boolean;

            property eventKey

            eventKey?: any;

              property expanded

              expanded?: boolean;

                property footer

                footer?: React.ReactNode;

                  property header

                  header?: React.ReactNode;

                    interface AlertProps

                    interface AlertProps extends React.HTMLProps<Alert> {}

                      property bsClass

                      bsClass?: string;

                        property bsSize

                        bsSize?: Sizes;

                          property bsStyle

                          bsStyle?: string;

                            property closeLabel

                            closeLabel?: string;

                              property dismissAfter

                              dismissAfter?: number;
                              • Deprecated

                                since v0.29.0

                              property onDismiss

                              onDismiss?: Function;

                                interface BadgeProps

                                interface BadgeProps extends React.HTMLProps<Badge> {}

                                  property bsClass

                                  bsClass?: string;

                                    property pullRight

                                    pullRight?: boolean;
                                      interface BreadcrumbItemProps extends React.Props<BreadcrumbItem> {}
                                        active?: boolean;
                                          href?: string;
                                            target?: string;
                                              title?: React.ReactNode;
                                                interface BreadcrumbProps extends React.HTMLProps<Breadcrumb> {}
                                                  bsClass?: string;

                                                    interface ButtonGroupProps

                                                    interface ButtonGroupProps extends React.HTMLProps<ButtonGroup> {}

                                                      property block

                                                      block?: boolean;

                                                        property bsClass

                                                        bsClass?: string;

                                                          property bsSize

                                                          bsSize?: Sizes;

                                                            property bsStyle

                                                            bsStyle?: string;

                                                              property justified

                                                              justified?: boolean;

                                                                property vertical

                                                                vertical?: boolean;

                                                                  interface ButtonProps

                                                                  interface ButtonProps extends React.HTMLProps<Button> {}

                                                                    property active

                                                                    active?: boolean;

                                                                      property block

                                                                      block?: boolean;

                                                                        property bsClass

                                                                        bsClass?: string;

                                                                          property bsSize

                                                                          bsSize?: Sizes;

                                                                            property bsStyle

                                                                            bsStyle?: string | null;

                                                                              property componentClass

                                                                              componentClass?: React.ReactType;

                                                                                property disabled

                                                                                disabled?: boolean;

                                                                                  interface ButtonToolbarProps

                                                                                  interface ButtonToolbarProps extends React.HTMLProps<ButtonToolbar> {}

                                                                                    property block

                                                                                    block?: boolean;

                                                                                      property bsClass

                                                                                      bsClass?: string;

                                                                                        property bsSize

                                                                                        bsSize?: Sizes;

                                                                                          property bsStyle

                                                                                          bsStyle?: string;

                                                                                            property justified

                                                                                            justified?: boolean;

                                                                                              property vertical

                                                                                              vertical?: boolean;

                                                                                                interface CarouselItemProps

                                                                                                interface CarouselItemProps extends React.HTMLProps<CarouselItem> {}

                                                                                                  property active

                                                                                                  active?: boolean;

                                                                                                    property animateOut

                                                                                                    animateOut?: boolean;

                                                                                                      property animtateIn

                                                                                                      animtateIn?: boolean;

                                                                                                        property direction

                                                                                                        direction?: string;

                                                                                                          property index

                                                                                                          index?: number;

                                                                                                            property onAnimateOutEnd

                                                                                                            onAnimateOutEnd?: Function;

                                                                                                              interface CheckboxProps

                                                                                                              interface CheckboxProps extends React.HTMLProps<Checkbox> {}

                                                                                                                property bsClass

                                                                                                                bsClass?: string;

                                                                                                                  property disabled

                                                                                                                  disabled?: boolean;

                                                                                                                    property inline

                                                                                                                    inline?: boolean;

                                                                                                                      property inputRef

                                                                                                                      inputRef?: (instance: HTMLInputElement) => void;

                                                                                                                        property validationState

                                                                                                                        validationState?: 'success' | 'warning' | 'error';

                                                                                                                          interface ClearfixProps

                                                                                                                          interface ClearfixProps extends React.HTMLProps<Clearfix> {}

                                                                                                                            property bsClass

                                                                                                                            bsClass?: string;

                                                                                                                              property componentClass

                                                                                                                              componentClass?: React.ReactType;

                                                                                                                                property visibleLgBlock

                                                                                                                                visibleLgBlock?: boolean;

                                                                                                                                  property visibleMdBlock

                                                                                                                                  visibleMdBlock?: boolean;

                                                                                                                                    property visibleSmBlock

                                                                                                                                    visibleSmBlock?: boolean;

                                                                                                                                      property visibleXsBlock

                                                                                                                                      visibleXsBlock?: boolean;

                                                                                                                                        interface CollapseProps

                                                                                                                                        interface CollapseProps
                                                                                                                                        extends TransitionCallbacks,
                                                                                                                                        React.ClassAttributes<Collapse> {}

                                                                                                                                          property dimension

                                                                                                                                          dimension?: 'height' | 'width' | { (): string };

                                                                                                                                            property getDimensionValue

                                                                                                                                            getDimensionValue?: (dimension: number, element: React.ReactElement) => number;

                                                                                                                                              property in

                                                                                                                                              in?: boolean;

                                                                                                                                                property mountOnEnter

                                                                                                                                                mountOnEnter?: boolean;

                                                                                                                                                  property timeout

                                                                                                                                                  timeout?: number;

                                                                                                                                                    property transitionAppear

                                                                                                                                                    transitionAppear?: boolean;

                                                                                                                                                      property unmountOnExit

                                                                                                                                                      unmountOnExit?: boolean;

                                                                                                                                                        interface ColProps

                                                                                                                                                        interface ColProps extends React.HTMLProps<Col> {}

                                                                                                                                                          property componentClass

                                                                                                                                                          componentClass?: React.ReactType;

                                                                                                                                                            property lg

                                                                                                                                                            lg?: number;

                                                                                                                                                              property lgHidden

                                                                                                                                                              lgHidden?: boolean;

                                                                                                                                                                property lgOffset

                                                                                                                                                                lgOffset?: number;

                                                                                                                                                                  property lgPull

                                                                                                                                                                  lgPull?: number;

                                                                                                                                                                    property lgPush

                                                                                                                                                                    lgPush?: number;

                                                                                                                                                                      property md

                                                                                                                                                                      md?: number;

                                                                                                                                                                        property mdHidden

                                                                                                                                                                        mdHidden?: boolean;

                                                                                                                                                                          property mdOffset

                                                                                                                                                                          mdOffset?: number;

                                                                                                                                                                            property mdPull

                                                                                                                                                                            mdPull?: number;

                                                                                                                                                                              property mdPush

                                                                                                                                                                              mdPush?: number;

                                                                                                                                                                                property sm

                                                                                                                                                                                sm?: number;

                                                                                                                                                                                  property smHidden

                                                                                                                                                                                  smHidden?: boolean;

                                                                                                                                                                                    property smOffset

                                                                                                                                                                                    smOffset?: number;

                                                                                                                                                                                      property smPull

                                                                                                                                                                                      smPull?: number;

                                                                                                                                                                                        property smPush

                                                                                                                                                                                        smPush?: number;

                                                                                                                                                                                          property xs

                                                                                                                                                                                          xs?: number;

                                                                                                                                                                                            property xsHidden

                                                                                                                                                                                            xsHidden?: boolean;

                                                                                                                                                                                              property xsOffset

                                                                                                                                                                                              xsOffset?: number;

                                                                                                                                                                                                property xsPull

                                                                                                                                                                                                xsPull?: number;

                                                                                                                                                                                                  property xsPush

                                                                                                                                                                                                  xsPush?: number;

                                                                                                                                                                                                    interface ControlLabelProps

                                                                                                                                                                                                    interface ControlLabelProps extends React.HTMLProps<ControlLabel> {}

                                                                                                                                                                                                      property bsClass

                                                                                                                                                                                                      bsClass?: string;

                                                                                                                                                                                                        property htmlFor

                                                                                                                                                                                                        htmlFor?: string;

                                                                                                                                                                                                          property srOnly

                                                                                                                                                                                                          srOnly?: boolean;

                                                                                                                                                                                                            interface FadeProps

                                                                                                                                                                                                            interface FadeProps extends TransitionCallbacks, React.HTMLProps<Fade> {}

                                                                                                                                                                                                              property appear

                                                                                                                                                                                                              appear?: boolean;

                                                                                                                                                                                                                property in

                                                                                                                                                                                                                in?: boolean;

                                                                                                                                                                                                                  property mountOnEnter

                                                                                                                                                                                                                  mountOnEnter?: boolean;

                                                                                                                                                                                                                    property timeout

                                                                                                                                                                                                                    timeout?: number;

                                                                                                                                                                                                                      property unmountOnExit

                                                                                                                                                                                                                      unmountOnExit?: boolean;

                                                                                                                                                                                                                        interface FormControlFeedbackProps

                                                                                                                                                                                                                        interface FormControlFeedbackProps extends React.HTMLProps<FormControlFeedback> {}

                                                                                                                                                                                                                          property bsClass

                                                                                                                                                                                                                          bsClass?: string;

                                                                                                                                                                                                                            interface FormControlProps

                                                                                                                                                                                                                            interface FormControlProps extends React.HTMLProps<FormControl> {}

                                                                                                                                                                                                                              property bsClass

                                                                                                                                                                                                                              bsClass?: string;

                                                                                                                                                                                                                                property bsSize

                                                                                                                                                                                                                                bsSize?: Sizes;

                                                                                                                                                                                                                                  property componentClass

                                                                                                                                                                                                                                  componentClass?: React.ReactType;

                                                                                                                                                                                                                                    property id

                                                                                                                                                                                                                                    id?: string;

                                                                                                                                                                                                                                      property inputRef

                                                                                                                                                                                                                                      inputRef?: (instance: HTMLInputElement) => void;

                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                        type?: string;

                                                                                                                                                                                                                                          interface FormControlStaticProps

                                                                                                                                                                                                                                          interface FormControlStaticProps extends React.HTMLProps<FormControlStatic> {}

                                                                                                                                                                                                                                            property bsClass

                                                                                                                                                                                                                                            bsClass?: string;

                                                                                                                                                                                                                                              property componentClass

                                                                                                                                                                                                                                              componentClass?: React.ReactType;

                                                                                                                                                                                                                                                interface FormGroupProps

                                                                                                                                                                                                                                                interface FormGroupProps extends React.HTMLProps<FormGroup> {}

                                                                                                                                                                                                                                                  property bsClass

                                                                                                                                                                                                                                                  bsClass?: string;

                                                                                                                                                                                                                                                    property bsSize

                                                                                                                                                                                                                                                    bsSize?: Sizes;

                                                                                                                                                                                                                                                      property controlId

                                                                                                                                                                                                                                                      controlId?: string;

                                                                                                                                                                                                                                                        property validationState

                                                                                                                                                                                                                                                        validationState?: 'success' | 'warning' | 'error' | null;

                                                                                                                                                                                                                                                          interface FormProps

                                                                                                                                                                                                                                                          interface FormProps extends React.HTMLProps<Form> {}

                                                                                                                                                                                                                                                            property bsClass

                                                                                                                                                                                                                                                            bsClass?: string;

                                                                                                                                                                                                                                                              property componentClass

                                                                                                                                                                                                                                                              componentClass?: React.ReactType;

                                                                                                                                                                                                                                                                property horizontal

                                                                                                                                                                                                                                                                horizontal?: boolean;

                                                                                                                                                                                                                                                                  property inline

                                                                                                                                                                                                                                                                  inline?: boolean;

                                                                                                                                                                                                                                                                    interface GlyphiconProps

                                                                                                                                                                                                                                                                    interface GlyphiconProps extends React.HTMLProps<Glyphicon> {}

                                                                                                                                                                                                                                                                      property bsClass

                                                                                                                                                                                                                                                                      bsClass?: string;

                                                                                                                                                                                                                                                                        property glyph

                                                                                                                                                                                                                                                                        glyph: string;

                                                                                                                                                                                                                                                                          interface GridProps

                                                                                                                                                                                                                                                                          interface GridProps extends React.HTMLProps<Grid> {}

                                                                                                                                                                                                                                                                            property bsClass

                                                                                                                                                                                                                                                                            bsClass?: string;

                                                                                                                                                                                                                                                                              property componentClass

                                                                                                                                                                                                                                                                              componentClass?: React.ReactType;

                                                                                                                                                                                                                                                                                property fluid

                                                                                                                                                                                                                                                                                fluid?: boolean;

                                                                                                                                                                                                                                                                                  interface HelpBlockProps

                                                                                                                                                                                                                                                                                  interface HelpBlockProps extends React.HTMLProps<HelpBlock> {}

                                                                                                                                                                                                                                                                                    property bsClass

                                                                                                                                                                                                                                                                                    bsClass?: string;

                                                                                                                                                                                                                                                                                      interface ImageProps

                                                                                                                                                                                                                                                                                      interface ImageProps extends React.HTMLProps<Image> {}

                                                                                                                                                                                                                                                                                        property circle

                                                                                                                                                                                                                                                                                        circle?: boolean;

                                                                                                                                                                                                                                                                                          property responsive

                                                                                                                                                                                                                                                                                          responsive?: boolean;

                                                                                                                                                                                                                                                                                            property rounded

                                                                                                                                                                                                                                                                                            rounded?: boolean;

                                                                                                                                                                                                                                                                                              property thumbnail

                                                                                                                                                                                                                                                                                              thumbnail?: boolean;

                                                                                                                                                                                                                                                                                                interface InputGroupAddonProps

                                                                                                                                                                                                                                                                                                interface InputGroupAddonProps extends React.HTMLProps<InputGroupAddon> {}

                                                                                                                                                                                                                                                                                                  property bsClass

                                                                                                                                                                                                                                                                                                  bsClass?: string;

                                                                                                                                                                                                                                                                                                    interface InputGroupButtonProps

                                                                                                                                                                                                                                                                                                    interface InputGroupButtonProps extends React.HTMLProps<InputGroupButton> {}

                                                                                                                                                                                                                                                                                                      property bsClass

                                                                                                                                                                                                                                                                                                      bsClass?: string;

                                                                                                                                                                                                                                                                                                        interface InputGroupProps

                                                                                                                                                                                                                                                                                                        interface InputGroupProps extends React.HTMLProps<InputGroup> {}

                                                                                                                                                                                                                                                                                                          property bsClass

                                                                                                                                                                                                                                                                                                          bsClass?: string;

                                                                                                                                                                                                                                                                                                            property bsSize

                                                                                                                                                                                                                                                                                                            bsSize?: Sizes;

                                                                                                                                                                                                                                                                                                              interface JumbotronProps

                                                                                                                                                                                                                                                                                                              interface JumbotronProps extends React.HTMLProps<Jumbotron> {}

                                                                                                                                                                                                                                                                                                                property componentClass

                                                                                                                                                                                                                                                                                                                componentClass?: React.ReactType;

                                                                                                                                                                                                                                                                                                                  interface LabelProps

                                                                                                                                                                                                                                                                                                                  interface LabelProps extends React.HTMLProps<Label> {}

                                                                                                                                                                                                                                                                                                                    property bsSize

                                                                                                                                                                                                                                                                                                                    bsSize?: Sizes;

                                                                                                                                                                                                                                                                                                                      property bsStyle

                                                                                                                                                                                                                                                                                                                      bsStyle?: string;

                                                                                                                                                                                                                                                                                                                        interface ListGroupItemProps

                                                                                                                                                                                                                                                                                                                        interface ListGroupItemProps extends React.HTMLProps<ListGroupItem> {}

                                                                                                                                                                                                                                                                                                                          property active

                                                                                                                                                                                                                                                                                                                          active?: any;

                                                                                                                                                                                                                                                                                                                            property bsSize

                                                                                                                                                                                                                                                                                                                            bsSize?: Sizes;

                                                                                                                                                                                                                                                                                                                              property bsStyle

                                                                                                                                                                                                                                                                                                                              bsStyle?: string;

                                                                                                                                                                                                                                                                                                                                property eventKey

                                                                                                                                                                                                                                                                                                                                eventKey?: any;

                                                                                                                                                                                                                                                                                                                                  property header

                                                                                                                                                                                                                                                                                                                                  header?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                    property listItem

                                                                                                                                                                                                                                                                                                                                    listItem?: boolean;

                                                                                                                                                                                                                                                                                                                                      interface ListGroupProps

                                                                                                                                                                                                                                                                                                                                      interface ListGroupProps extends React.HTMLProps<ListGroup> {}

                                                                                                                                                                                                                                                                                                                                        property bsClass

                                                                                                                                                                                                                                                                                                                                        bsClass?: string;

                                                                                                                                                                                                                                                                                                                                          property componentClass

                                                                                                                                                                                                                                                                                                                                          componentClass?: React.ReactType;

                                                                                                                                                                                                                                                                                                                                            property fill

                                                                                                                                                                                                                                                                                                                                            fill?: boolean;

                                                                                                                                                                                                                                                                                                                                              interface MediaProps

                                                                                                                                                                                                                                                                                                                                              interface MediaProps extends React.HTMLProps<Media> {}

                                                                                                                                                                                                                                                                                                                                                property componentClass

                                                                                                                                                                                                                                                                                                                                                componentClass?: React.ReactType;
                                                                                                                                                                                                                                                                                                                                                  interface MenuItemProps extends React.HTMLProps<MenuItem> {}
                                                                                                                                                                                                                                                                                                                                                    active?: boolean;
                                                                                                                                                                                                                                                                                                                                                      bsClass?: string;
                                                                                                                                                                                                                                                                                                                                                        disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                          divider?: boolean;
                                                                                                                                                                                                                                                                                                                                                            eventKey?: any;
                                                                                                                                                                                                                                                                                                                                                              header?: boolean;
                                                                                                                                                                                                                                                                                                                                                                onClick?: React.MouseEventHandler<{}>;
                                                                                                                                                                                                                                                                                                                                                                  onSelect?: SelectCallback;
                                                                                                                                                                                                                                                                                                                                                                    target?: string;
                                                                                                                                                                                                                                                                                                                                                                      title?: string;

                                                                                                                                                                                                                                                                                                                                                                        interface ModalBodyProps

                                                                                                                                                                                                                                                                                                                                                                        interface ModalBodyProps extends React.HTMLProps<ModalBody> {}

                                                                                                                                                                                                                                                                                                                                                                          property bsClass

                                                                                                                                                                                                                                                                                                                                                                          bsClass?: string;

                                                                                                                                                                                                                                                                                                                                                                            property componentClass

                                                                                                                                                                                                                                                                                                                                                                            componentClass?: React.ReactType;

                                                                                                                                                                                                                                                                                                                                                                              interface ModalDialogProps

                                                                                                                                                                                                                                                                                                                                                                              interface ModalDialogProps extends React.HTMLProps<ModalDialog> {}

                                                                                                                                                                                                                                                                                                                                                                                property bsClass

                                                                                                                                                                                                                                                                                                                                                                                bsClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                  property bsSize

                                                                                                                                                                                                                                                                                                                                                                                  bsSize?: Sizes;

                                                                                                                                                                                                                                                                                                                                                                                    property onEnter

                                                                                                                                                                                                                                                                                                                                                                                    onEnter?: Function;

                                                                                                                                                                                                                                                                                                                                                                                      property onEntered

                                                                                                                                                                                                                                                                                                                                                                                      onEntered?: Function;

                                                                                                                                                                                                                                                                                                                                                                                        property onEntering

                                                                                                                                                                                                                                                                                                                                                                                        onEntering?: Function;

                                                                                                                                                                                                                                                                                                                                                                                          property onExit

                                                                                                                                                                                                                                                                                                                                                                                          onExit?: Function;

                                                                                                                                                                                                                                                                                                                                                                                            property onExited

                                                                                                                                                                                                                                                                                                                                                                                            onExited?: Function;

                                                                                                                                                                                                                                                                                                                                                                                              property onExiting

                                                                                                                                                                                                                                                                                                                                                                                              onExiting?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                property onHide

                                                                                                                                                                                                                                                                                                                                                                                                onHide?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                  interface ModalFooterProps

                                                                                                                                                                                                                                                                                                                                                                                                  interface ModalFooterProps extends React.HTMLProps<ModalFooter> {}

                                                                                                                                                                                                                                                                                                                                                                                                    property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                    bsClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                      property componentClass

                                                                                                                                                                                                                                                                                                                                                                                                      componentClass?: React.ReactType;

                                                                                                                                                                                                                                                                                                                                                                                                        interface ModalHeaderProps

                                                                                                                                                                                                                                                                                                                                                                                                        interface ModalHeaderProps extends React.HTMLProps<ModalHeader> {}

                                                                                                                                                                                                                                                                                                                                                                                                          property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                          bsClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                            property closeButton

                                                                                                                                                                                                                                                                                                                                                                                                            closeButton?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                              property closeLabel

                                                                                                                                                                                                                                                                                                                                                                                                              closeLabel?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                property onHide

                                                                                                                                                                                                                                                                                                                                                                                                                onHide?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                  interface ModalProps

                                                                                                                                                                                                                                                                                                                                                                                                                  interface ModalProps extends TransitionCallbacks, React.HTMLProps<Modal> {}

                                                                                                                                                                                                                                                                                                                                                                                                                    property animation

                                                                                                                                                                                                                                                                                                                                                                                                                    animation?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                      property autoFocus

                                                                                                                                                                                                                                                                                                                                                                                                                      autoFocus?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                        property backdrop

                                                                                                                                                                                                                                                                                                                                                                                                                        backdrop?: boolean | string;

                                                                                                                                                                                                                                                                                                                                                                                                                          property backdropClassName

                                                                                                                                                                                                                                                                                                                                                                                                                          backdropClassName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                            property backdropStyle

                                                                                                                                                                                                                                                                                                                                                                                                                            backdropStyle?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                              property backdropTransitionTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                              backdropTransitionTimeout?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                bsClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property bsSize

                                                                                                                                                                                                                                                                                                                                                                                                                                  bsSize?: Sizes;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property container

                                                                                                                                                                                                                                                                                                                                                                                                                                    container?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property containerClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                      containerClassName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property dialogClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                        dialogClassName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property dialogComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                          dialogComponent?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property dialogTransitionTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                            dialogTransitionTimeout?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property enforceFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                              enforceFocus?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property keyboard

                                                                                                                                                                                                                                                                                                                                                                                                                                                keyboard?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onBackdropClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                  onBackdropClick?: (node: HTMLElement) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onEscapeKeyDown

                                                                                                                                                                                                                                                                                                                                                                                                                                                    onEscapeKeyDown?: (node: HTMLElement) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onEscapeKeyUp

                                                                                                                                                                                                                                                                                                                                                                                                                                                      onEscapeKeyUp?: (node: HTMLElement) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                        since Sept 25, 2017, use onEscapeKeyDown instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onHide

                                                                                                                                                                                                                                                                                                                                                                                                                                                      onHide: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onShow

                                                                                                                                                                                                                                                                                                                                                                                                                                                        onShow?: (node: HTMLElement) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property restoreFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                          restoreFocus?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property show

                                                                                                                                                                                                                                                                                                                                                                                                                                                            show?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property transition

                                                                                                                                                                                                                                                                                                                                                                                                                                                              transition?: React.ReactElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ModalTitleProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ModalTitleProps extends React.HTMLProps<ModalTitle> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bsClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property componentClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    componentClass?: React.ReactType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface NavbarProps extends React.HTMLProps<Navbar> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        brand?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bsSize?: Sizes;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bsStyle?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              collapseOnSelect?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                componentClass?: React.ReactType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  defaultNavExpanded?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    expanded?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fixedBottom?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fixedTop?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fluid?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            inverse?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onToggle?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                staticTop?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  toggleButton?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toggleNavKey?: string | number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface NavItemProps extends React.HTMLProps<NavItem> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        active?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          brand?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bsSize?: Sizes;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bsStyle?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                componentClass?: React.ReactType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  defaultNavExpanded?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    eventKey?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fixedBottom?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fixedTop?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fluid?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            inverse?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              linkId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                navExpanded?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onSelect?: SelectCallback;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onToggle?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      staticTop?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        toggleButton?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toggleNavKey?: string | number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface NavProps extends React.HTMLProps<Nav> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              activeHref?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                activeKey?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bsClass?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bsSize?: Sizes;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bsStyle?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        collapsible?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          eventKey?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            expanded?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              justified?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                navbar?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pullRight?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    right?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stacked?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ulClassName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ulId?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface OverlayProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface OverlayProps extends TransitionCallbacks {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property animation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              animation?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property container

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                container?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property containerPadding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  containerPadding?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onHide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onHide?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property placement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      placement?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property rootClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rootClose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property shouldUpdatePosition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          shouldUpdatePosition?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            show?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property target

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              target?: Function | React.ReactInstance;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface OverlayTriggerProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface OverlayTriggerProps extends React.Props<OverlayTrigger> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property animation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  animation?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property container

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    container?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property containerPadding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      containerPadding?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaultOverlayShown

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defaultOverlayShown?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property delay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delay?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property delayHide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            delayHide?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property delayShow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              delayShow?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onEnter?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onEntered

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onEntered?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onEntering

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onEntering?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onExit?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onExited

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onExited?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onExiting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onExiting?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property overlay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            overlay: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property placement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              placement?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property rootClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                rootClose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property trigger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  trigger?: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PageHeaderProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PageHeaderProps extends React.HTMLProps<PageHeader> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bsClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PagerProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PagerProps extends React.HTMLProps<Pager> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bsClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onSelect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onSelect?: SelectCallback;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PaginationProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PaginationProps extends React.HTMLProps<Pagination> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property bsSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bsSize?: Sizes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PanelGroupProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PanelGroupProps extends React.HTMLProps<PanelGroup> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property accordion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    accordion?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property activeKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      activeKey?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaultActiveKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defaultActiveKey?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property generateChildId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          generateChildId?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onSelect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onSelect?: SelectCallback;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property role

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              role?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PanelProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PanelProps extends TransitionCallbacks, React.HTMLProps<Panel> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bsClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property bsStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bsStyle?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property defaultExpanded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      defaultExpanded?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property eventKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        eventKey?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property expanded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          expanded?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onSelect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onSelect?: SelectCallback;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onToggle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onToggle?: SelectCallback;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PopoverProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PopoverProps extends Omit<React.HTMLProps<Popover>, 'title'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property arrowOffsetLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  arrowOffsetLeft?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property arrowOffsetTop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    arrowOffsetTop?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bsClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property bsSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bsSize?: Sizes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property bsStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bsStyle?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property placement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            placement?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property positionLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              positionLeft?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property positionTop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                positionTop?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  title?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ProgressBarProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ProgressBarProps extends Omit<React.HTMLProps<ProgressBar>, 'label'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property active

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      active?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bsClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property bsSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bsSize?: Sizes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property bsStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bsStyle?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property interpolatedClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interpolatedClass?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                label?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property max

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  max?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property min

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    min?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property now

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      now?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property srOnly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        srOnly?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property striped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          striped?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RadioProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RadioProps extends React.HTMLProps<Radio> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bsClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                disabled?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property inline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  inline?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property inputRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    inputRef?: (instance: HTMLInputElement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property validationState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      validationState?: 'success' | 'warning' | 'error';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResponsiveEmbedProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResponsiveEmbedProps extends React.HTMLProps<ResponsiveEmbed> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property a16by9

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          a16by9?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property a4by3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            a4by3?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bsClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface RowProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface RowProps extends React.HTMLProps<Row> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property componentClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  componentClass?: React.ReactType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SafeAnchorProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SafeAnchorProps extends React.HTMLProps<SafeAnchor> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property componentClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      componentClass?: React.ReactType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        disabled?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property href

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          href?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onClick?: React.MouseEventHandler<{}>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property role

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              role?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SelectCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SelectCallback extends React.EventHandler<any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (eventKey: any, e: React.SyntheticEvent<{}>): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (e: React.MouseEvent<{}>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This signature is a hack so can still derive from HTMLProps. It does not reflect the underlying event and should not be used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SplitButtonProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SplitButtonProps extends Omit<React.HTMLProps<SplitButton>, 'title'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property bsSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bsSize?: Sizes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property bsStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bsStyle?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property dropdownTitle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          dropdownTitle?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property dropup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            dropup?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property pullRight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                pullRight?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  title: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TabContainerProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TabContainerProps extends React.HTMLAttributes<TabContainer> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property activeKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      activeKey?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaultActiveKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defaultActiveKey?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property generateChildId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          generateChildId?: (eventKey: any, type: any) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TabContentProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TabContentProps extends React.HTMLProps<TabContent> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property animation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              animation?: boolean | React.ReactType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bsClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property componentClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  componentClass?: React.ReactType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property mountOnEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mountOnEnter?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property unmountOnExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      unmountOnExit?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TableProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TableProps extends React.HTMLProps<Table> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property bordered

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bordered?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bsClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property condensed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              condensed?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property fill

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fill?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property hover

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hover?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property responsive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    responsive?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property striped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      striped?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TabPaneProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TabPaneProps extends TransitionCallbacks, React.HTMLProps<TabPane> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property 'aria-labelledby'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'aria-labelledby'?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property animation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            animation?: boolean | React.ComponentClass<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bsClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property eventKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                eventKey?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property mountOnEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  mountOnEnter?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property unmountOnExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    unmountOnExit?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface TabProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface TabProps
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      extends TransitionCallbacks,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Omit<React.HTMLProps<Tab>, 'title'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property 'aria-labelledby'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'aria-labelledby'?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property animation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          animation?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bsClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property eventKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              eventKey?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property tabClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tabClassName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  title?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property unmountOnExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    unmountOnExit?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface TabsProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface TabsProps extends React.HTMLProps<Tabs> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property activeKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        activeKey?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property animation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          animation?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property bsStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bsStyle?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property defaultActiveKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              defaultActiveKey?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property justified

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                justified?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property mountOnEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  mountOnEnter?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onSelect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onSelect?: SelectCallback;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property paneWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      paneWidth?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        position?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tabWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tabWidth?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property unmountOnExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            unmountOnExit?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ThumbnailProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ThumbnailProps extends React.HTMLProps<Thumbnail> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property bsSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bsSize?: Sizes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property bsStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bsStyle?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ToggleButtonProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ToggleButtonProps extends React.HTMLProps<ToggleButton> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property checked

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      checked?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          value: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TooltipProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TooltipProps extends React.HTMLProps<Tooltip> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property arrowOffsetLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              arrowOffsetLeft?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property arrowOffsetTop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                arrowOffsetTop?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bsClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property bsSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bsSize?: Sizes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property bsStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bsStyle?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property placement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        placement?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property positionLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          positionLeft?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property positionTop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            positionTop?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface TransitionCallbacks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface TransitionCallbacks {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method onEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onEnter: (node: HTMLElement) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method onEntered

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onEntered: (node: HTMLElement) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method onEntering

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onEntering: (node: HTMLElement) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method onExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onExit: (node: HTMLElement) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method onExited

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onExited: (node: HTMLElement) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method onExiting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onExiting: (node: HTMLElement) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface WellProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface WellProps extends React.HTMLProps<Well> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bsClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property bsSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bsSize?: Sizes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property bsStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bsStyle?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CarouselProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CarouselProps = Omit<React.HTMLProps<Carousel>, 'wrap'> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    activeIndex?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bsSize?: Sizes;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bsStyle?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    controls?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    defaultActiveIndex?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    direction?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    indicators?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interval?: number | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nextIcon?: React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onSelect?: SelectCallback;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // TODO: Add more specific type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onSlideEnd?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pauseOnHover?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    prevIcon?: React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    slide?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    wrap?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DropdownButtonProps = DropdownButtonBaseProps &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Omit<React.HTMLProps<DropdownButton>, 'title'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DropdownProps = Dropdown.DropdownBaseProps & React.HTMLProps<Dropdown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type NavbarBrandProps = React.HTMLProps<NavbarBrand>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type NavDropdownProps = NavDropdownBaseProps &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Omit<React.HTMLProps<NavDropdown>, 'title'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Omit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Omit<T, K extends keyof T> = Pick<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ({ [P in keyof T]: P } &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { [P in K]: never } & { [x: string]: never; [x: number]: never })[keyof T]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type PageItemProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type PageItemProps = PagerItemProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Sizes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Sizes = 'xs' | 'xsmall' | 'sm' | 'small' | 'medium' | 'lg' | 'large';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SplitToggleProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SplitToggleProps = DropdownToggleProps & React.HTMLProps<SplitToggle>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ToggleButtonGroupProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ToggleButtonGroupProps = BaseProps &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (RadioProps | CheckboxProps) &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Omit<ButtonGroup.ButtonGroupProps, 'onChange'> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Omit<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      React.HTMLProps<ToggleButtonGroup>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'defaultValue' | 'type' | 'value' | 'onChange'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Namespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace utils

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        module 'lib/utils/index.d.ts' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function createChainedFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createChainedFunction: (...funcs: Function[]) => Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace bootstrapUtils

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            module 'lib/utils/bootstrapUtils.d.ts' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function addStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              addStyle: (Component: any, ...styleVariant: any[]) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bsClass: (defaultClass: any, Component: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function bsSizes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bsSizes: (sizes: any, defaultSize: any, Component: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function bsStyles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bsStyles: (styles: any, defaultStyle: any, Component: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function getBsProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getBsProps: (props: any) => BSProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function getClassSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getClassSet: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function isBsProp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isBsProp: (propName: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function prefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            prefix: (props: { bsClass?: any }, variant?: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function splitBsProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              splitBsProps: (props: any) => [BSProps, any];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function splitBsPropsAndOmit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                splitBsPropsAndOmit: (props: any, omittedPropNames: any) => [BSProps, any];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface BSProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface BSProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bsClass: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property bsRole

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bsRole: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property bsSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bsSize: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property bsStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bsStyle: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Package Files (78)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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/react-bootstrap.

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