@types/react-bootstrap

  • Version 0.32.30
  • Published
  • 73.9 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 | undefined;

      property bsStyle

      bsStyle?: string | undefined;

        property collapsible

        collapsible?: boolean | undefined;

          property defaultExpanded

          defaultExpanded?: boolean | undefined;

            property eventKey

            eventKey?: any;

              property expanded

              expanded?: boolean | undefined;

                property footer

                footer?: React.ReactNode | undefined;

                  property header

                  header?: React.ReactNode | undefined;

                    interface AlertProps

                    interface AlertProps extends React.HTMLProps<Alert> {}

                      property bsClass

                      bsClass?: string | undefined;

                        property bsSize

                        bsSize?: Sizes | undefined;

                          property bsStyle

                          bsStyle?: string | undefined;

                            property closeLabel

                            closeLabel?: string | undefined;

                              property dismissAfter

                              dismissAfter?: number | undefined;
                              • Deprecated

                                since v0.29.0

                              property onDismiss

                              onDismiss?: Function | undefined;

                                interface BadgeProps

                                interface BadgeProps extends React.HTMLProps<Badge> {}

                                  property bsClass

                                  bsClass?: string | undefined;

                                    property pullRight

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

                                                        interface ButtonGroupProps

                                                        interface ButtonGroupProps extends React.HTMLProps<ButtonGroup> {}

                                                          property block

                                                          block?: boolean | undefined;

                                                            property bsClass

                                                            bsClass?: string | undefined;

                                                              property bsSize

                                                              bsSize?: Sizes | undefined;

                                                                property bsStyle

                                                                bsStyle?: string | undefined;

                                                                  property justified

                                                                  justified?: boolean | undefined;

                                                                    property vertical

                                                                    vertical?: boolean | undefined;

                                                                      interface ButtonProps

                                                                      interface ButtonProps extends React.HTMLProps<Button> {}

                                                                        property active

                                                                        active?: boolean | undefined;

                                                                          property block

                                                                          block?: boolean | undefined;

                                                                            property bsClass

                                                                            bsClass?: string | undefined;

                                                                              property bsSize

                                                                              bsSize?: Sizes | undefined;

                                                                                property bsStyle

                                                                                bsStyle?: string | null | undefined;

                                                                                  property componentClass

                                                                                  componentClass?: React.ElementType | undefined;

                                                                                    property disabled

                                                                                    disabled?: boolean | undefined;

                                                                                      interface ButtonToolbarProps

                                                                                      interface ButtonToolbarProps extends React.HTMLProps<ButtonToolbar> {}

                                                                                        property block

                                                                                        block?: boolean | undefined;

                                                                                          property bsClass

                                                                                          bsClass?: string | undefined;

                                                                                            property bsSize

                                                                                            bsSize?: Sizes | undefined;

                                                                                              property bsStyle

                                                                                              bsStyle?: string | undefined;

                                                                                                property justified

                                                                                                justified?: boolean | undefined;

                                                                                                  property vertical

                                                                                                  vertical?: boolean | undefined;

                                                                                                    interface CarouselItemProps

                                                                                                    interface CarouselItemProps extends React.HTMLProps<CarouselItem> {}

                                                                                                      property active

                                                                                                      active?: boolean | undefined;

                                                                                                        property animateOut

                                                                                                        animateOut?: boolean | undefined;

                                                                                                          property animtateIn

                                                                                                          animtateIn?: boolean | undefined;

                                                                                                            property direction

                                                                                                            direction?: string | undefined;

                                                                                                              property index

                                                                                                              index?: number | undefined;

                                                                                                                property onAnimateOutEnd

                                                                                                                onAnimateOutEnd?: Function | undefined;

                                                                                                                  interface CheckboxProps

                                                                                                                  interface CheckboxProps extends React.HTMLProps<Checkbox> {}

                                                                                                                    property bsClass

                                                                                                                    bsClass?: string | undefined;

                                                                                                                      property disabled

                                                                                                                      disabled?: boolean | undefined;

                                                                                                                        property inline

                                                                                                                        inline?: boolean | undefined;

                                                                                                                          property inputRef

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

                                                                                                                            property validationState

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

                                                                                                                              interface ClearfixProps

                                                                                                                              interface ClearfixProps extends React.HTMLProps<Clearfix> {}

                                                                                                                                property bsClass

                                                                                                                                bsClass?: string | undefined;

                                                                                                                                  property componentClass

                                                                                                                                  componentClass?: React.ElementType | undefined;

                                                                                                                                    property visibleLgBlock

                                                                                                                                    visibleLgBlock?: boolean | undefined;

                                                                                                                                      property visibleMdBlock

                                                                                                                                      visibleMdBlock?: boolean | undefined;

                                                                                                                                        property visibleSmBlock

                                                                                                                                        visibleSmBlock?: boolean | undefined;

                                                                                                                                          property visibleXsBlock

                                                                                                                                          visibleXsBlock?: boolean | undefined;

                                                                                                                                            interface CollapseProps

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

                                                                                                                                              property children

                                                                                                                                              children?: React.ReactNode;

                                                                                                                                                property dimension

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

                                                                                                                                                  property getDimensionValue

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

                                                                                                                                                    property in

                                                                                                                                                    in?: boolean | undefined;

                                                                                                                                                      property mountOnEnter

                                                                                                                                                      mountOnEnter?: boolean | undefined;

                                                                                                                                                        property timeout

                                                                                                                                                        timeout?: number | undefined;

                                                                                                                                                          property transitionAppear

                                                                                                                                                          transitionAppear?: boolean | undefined;

                                                                                                                                                            property unmountOnExit

                                                                                                                                                            unmountOnExit?: boolean | undefined;

                                                                                                                                                              interface ColProps

                                                                                                                                                              interface ColProps extends React.HTMLProps<Col> {}

                                                                                                                                                                property componentClass

                                                                                                                                                                componentClass?: React.ElementType | undefined;

                                                                                                                                                                  property lg

                                                                                                                                                                  lg?: number | undefined;

                                                                                                                                                                    property lgHidden

                                                                                                                                                                    lgHidden?: boolean | undefined;

                                                                                                                                                                      property lgOffset

                                                                                                                                                                      lgOffset?: number | undefined;

                                                                                                                                                                        property lgPull

                                                                                                                                                                        lgPull?: number | undefined;

                                                                                                                                                                          property lgPush

                                                                                                                                                                          lgPush?: number | undefined;

                                                                                                                                                                            property md

                                                                                                                                                                            md?: number | undefined;

                                                                                                                                                                              property mdHidden

                                                                                                                                                                              mdHidden?: boolean | undefined;

                                                                                                                                                                                property mdOffset

                                                                                                                                                                                mdOffset?: number | undefined;

                                                                                                                                                                                  property mdPull

                                                                                                                                                                                  mdPull?: number | undefined;

                                                                                                                                                                                    property mdPush

                                                                                                                                                                                    mdPush?: number | undefined;

                                                                                                                                                                                      property sm

                                                                                                                                                                                      sm?: number | undefined;

                                                                                                                                                                                        property smHidden

                                                                                                                                                                                        smHidden?: boolean | undefined;

                                                                                                                                                                                          property smOffset

                                                                                                                                                                                          smOffset?: number | undefined;

                                                                                                                                                                                            property smPull

                                                                                                                                                                                            smPull?: number | undefined;

                                                                                                                                                                                              property smPush

                                                                                                                                                                                              smPush?: number | undefined;

                                                                                                                                                                                                property xs

                                                                                                                                                                                                xs?: number | undefined;

                                                                                                                                                                                                  property xsHidden

                                                                                                                                                                                                  xsHidden?: boolean | undefined;

                                                                                                                                                                                                    property xsOffset

                                                                                                                                                                                                    xsOffset?: number | undefined;

                                                                                                                                                                                                      property xsPull

                                                                                                                                                                                                      xsPull?: number | undefined;

                                                                                                                                                                                                        property xsPush

                                                                                                                                                                                                        xsPush?: number | undefined;

                                                                                                                                                                                                          interface ControlLabelProps

                                                                                                                                                                                                          interface ControlLabelProps extends React.HTMLProps<ControlLabel> {}

                                                                                                                                                                                                            property bsClass

                                                                                                                                                                                                            bsClass?: string | undefined;

                                                                                                                                                                                                              property htmlFor

                                                                                                                                                                                                              htmlFor?: string | undefined;

                                                                                                                                                                                                                property srOnly

                                                                                                                                                                                                                srOnly?: boolean | undefined;

                                                                                                                                                                                                                  interface FadeProps

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

                                                                                                                                                                                                                    property appear

                                                                                                                                                                                                                    appear?: boolean | undefined;

                                                                                                                                                                                                                      property in

                                                                                                                                                                                                                      in?: boolean | undefined;

                                                                                                                                                                                                                        property mountOnEnter

                                                                                                                                                                                                                        mountOnEnter?: boolean | undefined;

                                                                                                                                                                                                                          property timeout

                                                                                                                                                                                                                          timeout?: number | undefined;

                                                                                                                                                                                                                            property unmountOnExit

                                                                                                                                                                                                                            unmountOnExit?: boolean | undefined;

                                                                                                                                                                                                                              interface FormControlFeedbackProps

                                                                                                                                                                                                                              interface FormControlFeedbackProps extends React.HTMLProps<FormControlFeedback> {}

                                                                                                                                                                                                                                property bsClass

                                                                                                                                                                                                                                bsClass?: string | undefined;

                                                                                                                                                                                                                                  interface FormControlProps

                                                                                                                                                                                                                                  interface FormControlProps extends React.HTMLProps<FormControl> {}

                                                                                                                                                                                                                                    property bsClass

                                                                                                                                                                                                                                    bsClass?: string | undefined;

                                                                                                                                                                                                                                      property bsSize

                                                                                                                                                                                                                                      bsSize?: Sizes | undefined;

                                                                                                                                                                                                                                        property componentClass

                                                                                                                                                                                                                                        componentClass?: React.ElementType | undefined;

                                                                                                                                                                                                                                          property id

                                                                                                                                                                                                                                          id?: string | undefined;

                                                                                                                                                                                                                                            property inputRef

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

                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                              type?: string | undefined;

                                                                                                                                                                                                                                                interface FormControlStaticProps

                                                                                                                                                                                                                                                interface FormControlStaticProps extends React.HTMLProps<FormControlStatic> {}

                                                                                                                                                                                                                                                  property bsClass

                                                                                                                                                                                                                                                  bsClass?: string | undefined;

                                                                                                                                                                                                                                                    property componentClass

                                                                                                                                                                                                                                                    componentClass?: React.ElementType | undefined;

                                                                                                                                                                                                                                                      interface FormGroupProps

                                                                                                                                                                                                                                                      interface FormGroupProps extends React.HTMLProps<FormGroup> {}

                                                                                                                                                                                                                                                        property bsClass

                                                                                                                                                                                                                                                        bsClass?: string | undefined;

                                                                                                                                                                                                                                                          property bsSize

                                                                                                                                                                                                                                                          bsSize?: Sizes | undefined;

                                                                                                                                                                                                                                                            property controlId

                                                                                                                                                                                                                                                            controlId?: string | undefined;

                                                                                                                                                                                                                                                              property validationState

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

                                                                                                                                                                                                                                                                interface FormProps

                                                                                                                                                                                                                                                                interface FormProps extends React.HTMLProps<Form> {}

                                                                                                                                                                                                                                                                  property bsClass

                                                                                                                                                                                                                                                                  bsClass?: string | undefined;

                                                                                                                                                                                                                                                                    property componentClass

                                                                                                                                                                                                                                                                    componentClass?: React.ElementType | undefined;

                                                                                                                                                                                                                                                                      property horizontal

                                                                                                                                                                                                                                                                      horizontal?: boolean | undefined;

                                                                                                                                                                                                                                                                        property inline

                                                                                                                                                                                                                                                                        inline?: boolean | undefined;

                                                                                                                                                                                                                                                                          interface GlyphiconProps

                                                                                                                                                                                                                                                                          interface GlyphiconProps extends React.HTMLProps<Glyphicon> {}

                                                                                                                                                                                                                                                                            property bsClass

                                                                                                                                                                                                                                                                            bsClass?: string | undefined;

                                                                                                                                                                                                                                                                              property glyph

                                                                                                                                                                                                                                                                              glyph: string;

                                                                                                                                                                                                                                                                                interface GridProps

                                                                                                                                                                                                                                                                                interface GridProps extends React.HTMLProps<Grid> {}

                                                                                                                                                                                                                                                                                  property bsClass

                                                                                                                                                                                                                                                                                  bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                    property componentClass

                                                                                                                                                                                                                                                                                    componentClass?: React.ElementType | undefined;

                                                                                                                                                                                                                                                                                      property fluid

                                                                                                                                                                                                                                                                                      fluid?: boolean | undefined;

                                                                                                                                                                                                                                                                                        interface HelpBlockProps

                                                                                                                                                                                                                                                                                        interface HelpBlockProps extends React.HTMLProps<HelpBlock> {}

                                                                                                                                                                                                                                                                                          property bsClass

                                                                                                                                                                                                                                                                                          bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                            interface ImageProps

                                                                                                                                                                                                                                                                                            interface ImageProps extends React.HTMLProps<Image> {}

                                                                                                                                                                                                                                                                                              property circle

                                                                                                                                                                                                                                                                                              circle?: boolean | undefined;

                                                                                                                                                                                                                                                                                                property responsive

                                                                                                                                                                                                                                                                                                responsive?: boolean | undefined;

                                                                                                                                                                                                                                                                                                  property rounded

                                                                                                                                                                                                                                                                                                  rounded?: boolean | undefined;

                                                                                                                                                                                                                                                                                                    property thumbnail

                                                                                                                                                                                                                                                                                                    thumbnail?: boolean | undefined;

                                                                                                                                                                                                                                                                                                      interface InputGroupAddonProps

                                                                                                                                                                                                                                                                                                      interface InputGroupAddonProps extends React.HTMLProps<InputGroupAddon> {}

                                                                                                                                                                                                                                                                                                        property bsClass

                                                                                                                                                                                                                                                                                                        bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                          interface InputGroupButtonProps

                                                                                                                                                                                                                                                                                                          interface InputGroupButtonProps extends React.HTMLProps<InputGroupButton> {}

                                                                                                                                                                                                                                                                                                            property bsClass

                                                                                                                                                                                                                                                                                                            bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                              interface InputGroupProps

                                                                                                                                                                                                                                                                                                              interface InputGroupProps extends React.HTMLProps<InputGroup> {}

                                                                                                                                                                                                                                                                                                                property bsClass

                                                                                                                                                                                                                                                                                                                bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                  property bsSize

                                                                                                                                                                                                                                                                                                                  bsSize?: Sizes | undefined;

                                                                                                                                                                                                                                                                                                                    interface JumbotronProps

                                                                                                                                                                                                                                                                                                                    interface JumbotronProps extends React.HTMLProps<Jumbotron> {}

                                                                                                                                                                                                                                                                                                                      property componentClass

                                                                                                                                                                                                                                                                                                                      componentClass?: React.ElementType | undefined;

                                                                                                                                                                                                                                                                                                                        interface LabelProps

                                                                                                                                                                                                                                                                                                                        interface LabelProps extends React.HTMLProps<Label> {}

                                                                                                                                                                                                                                                                                                                          property bsSize

                                                                                                                                                                                                                                                                                                                          bsSize?: Sizes | undefined;

                                                                                                                                                                                                                                                                                                                            property bsStyle

                                                                                                                                                                                                                                                                                                                            bsStyle?: string | undefined;

                                                                                                                                                                                                                                                                                                                              interface ListGroupItemProps

                                                                                                                                                                                                                                                                                                                              interface ListGroupItemProps extends React.HTMLProps<ListGroupItem> {}

                                                                                                                                                                                                                                                                                                                                property active

                                                                                                                                                                                                                                                                                                                                active?: any;

                                                                                                                                                                                                                                                                                                                                  property bsSize

                                                                                                                                                                                                                                                                                                                                  bsSize?: Sizes | undefined;

                                                                                                                                                                                                                                                                                                                                    property bsStyle

                                                                                                                                                                                                                                                                                                                                    bsStyle?: string | undefined;

                                                                                                                                                                                                                                                                                                                                      property eventKey

                                                                                                                                                                                                                                                                                                                                      eventKey?: any;

                                                                                                                                                                                                                                                                                                                                        property header

                                                                                                                                                                                                                                                                                                                                        header?: React.ReactNode | undefined;

                                                                                                                                                                                                                                                                                                                                          property listItem

                                                                                                                                                                                                                                                                                                                                          listItem?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                            interface ListGroupProps

                                                                                                                                                                                                                                                                                                                                            interface ListGroupProps extends React.HTMLProps<ListGroup> {}

                                                                                                                                                                                                                                                                                                                                              property bsClass

                                                                                                                                                                                                                                                                                                                                              bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                property componentClass

                                                                                                                                                                                                                                                                                                                                                componentClass?: React.ElementType | undefined;

                                                                                                                                                                                                                                                                                                                                                  property fill

                                                                                                                                                                                                                                                                                                                                                  fill?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                    interface MediaProps

                                                                                                                                                                                                                                                                                                                                                    interface MediaProps extends React.HTMLProps<Media> {}

                                                                                                                                                                                                                                                                                                                                                      property componentClass

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

                                                                                                                                                                                                                                                                                                                                                                              interface ModalBodyProps

                                                                                                                                                                                                                                                                                                                                                                              interface ModalBodyProps extends React.HTMLProps<ModalBody> {}

                                                                                                                                                                                                                                                                                                                                                                                property bsClass

                                                                                                                                                                                                                                                                                                                                                                                bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                  property componentClass

                                                                                                                                                                                                                                                                                                                                                                                  componentClass?: React.ElementType | undefined;

                                                                                                                                                                                                                                                                                                                                                                                    interface ModalDialogProps

                                                                                                                                                                                                                                                                                                                                                                                    interface ModalDialogProps extends React.HTMLProps<ModalDialog> {}

                                                                                                                                                                                                                                                                                                                                                                                      property bsClass

                                                                                                                                                                                                                                                                                                                                                                                      bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                        property bsSize

                                                                                                                                                                                                                                                                                                                                                                                        bsSize?: Sizes | undefined;

                                                                                                                                                                                                                                                                                                                                                                                          property onEnter

                                                                                                                                                                                                                                                                                                                                                                                          onEnter?: Function | undefined;

                                                                                                                                                                                                                                                                                                                                                                                            property onEntered

                                                                                                                                                                                                                                                                                                                                                                                            onEntered?: Function | undefined;

                                                                                                                                                                                                                                                                                                                                                                                              property onEntering

                                                                                                                                                                                                                                                                                                                                                                                              onEntering?: Function | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                property onExit

                                                                                                                                                                                                                                                                                                                                                                                                onExit?: Function | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                  property onExited

                                                                                                                                                                                                                                                                                                                                                                                                  onExited?: Function | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                    property onExiting

                                                                                                                                                                                                                                                                                                                                                                                                    onExiting?: Function | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                      property onHide

                                                                                                                                                                                                                                                                                                                                                                                                      onHide?: Function | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                        interface ModalFooterProps

                                                                                                                                                                                                                                                                                                                                                                                                        interface ModalFooterProps extends React.HTMLProps<ModalFooter> {}

                                                                                                                                                                                                                                                                                                                                                                                                          property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                          bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                            property componentClass

                                                                                                                                                                                                                                                                                                                                                                                                            componentClass?: React.ElementType | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                              interface ModalHeaderProps

                                                                                                                                                                                                                                                                                                                                                                                                              interface ModalHeaderProps extends React.HTMLProps<ModalHeader> {}

                                                                                                                                                                                                                                                                                                                                                                                                                property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                  property closeButton

                                                                                                                                                                                                                                                                                                                                                                                                                  closeButton?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                    property closeLabel

                                                                                                                                                                                                                                                                                                                                                                                                                    closeLabel?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                      property onHide

                                                                                                                                                                                                                                                                                                                                                                                                                      onHide?: Function | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                        interface ModalProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                          property animation

                                                                                                                                                                                                                                                                                                                                                                                                                          animation?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                            property autoFocus

                                                                                                                                                                                                                                                                                                                                                                                                                            autoFocus?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                              property backdrop

                                                                                                                                                                                                                                                                                                                                                                                                                              backdrop?: boolean | string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                property backdropClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                backdropClassName?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property backdropStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                  backdropStyle?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property backdropTransitionTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                    backdropTransitionTimeout?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                      bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property bsSize

                                                                                                                                                                                                                                                                                                                                                                                                                                        bsSize?: Sizes | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property container

                                                                                                                                                                                                                                                                                                                                                                                                                                          container?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property containerClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                            containerClassName?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property dialogClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                              dialogClassName?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property dialogComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                dialogComponent?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property dialogTransitionTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                  dialogTransitionTimeout?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property enforceFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                    enforceFocus?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property keyboard

                                                                                                                                                                                                                                                                                                                                                                                                                                                      keyboard?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onBackdropClick

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onEscapeKeyDown

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onEscapeKeyUp

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                              since Sept 25, 2017, use onEscapeKeyDown instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onHide

                                                                                                                                                                                                                                                                                                                                                                                                                                                            onHide: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onShow

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property restoreFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                restoreFocus?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  show?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property transition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    transition?: React.ReactElement | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ModalTitleProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ModalTitleProps extends React.HTMLProps<ModalTitle> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property componentClass

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface OverlayProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface OverlayProps extends TransitionCallbacks {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property animation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    animation?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      children?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property container

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        container?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property containerPadding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          containerPadding?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onHide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onHide?: Function | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property placement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              placement?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property rootClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                rootClose?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property shouldUpdatePosition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  shouldUpdatePosition?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property show

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    show?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property target

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      target?: Function | React.ReactInstance | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface OverlayTriggerProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface OverlayTriggerProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property animation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          animation?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            children?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property container

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              container?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property containerPadding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                containerPadding?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property defaultOverlayShown

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  defaultOverlayShown?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property delay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    delay?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property delayHide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      delayHide?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property delayShow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        delayShow?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onEnter?: Function | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onEntered

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onEntered?: Function | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onEntering

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onEntering?: Function | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onExit?: Function | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onExited

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onExited?: Function | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onExiting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onExiting?: Function | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property overlay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      overlay: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property placement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        placement?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ref

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ref?: React.LegacyRef<OverlayTrigger> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property rootClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            rootClose?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property trigger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              trigger?: string | string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PageHeaderProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PageHeaderProps extends React.HTMLProps<PageHeader> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PagerProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PagerProps extends React.HTMLProps<Pager> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onSelect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onSelect?: SelectCallback | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PaginationProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PaginationProps extends React.HTMLProps<Pagination> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property bsSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bsSize?: Sizes | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PanelGroupProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PanelGroupProps extends React.HTMLProps<PanelGroup> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property accordion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                accordion?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property activeKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  activeKey?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property defaultActiveKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    defaultActiveKey?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property generateChildId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      generateChildId?: Function | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onSelect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onSelect?: SelectCallback | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property role

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          role?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PanelProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property bsStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bsStyle?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property defaultExpanded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  defaultExpanded?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property eventKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    eventKey?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property expanded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      expanded?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onSelect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onSelect?: SelectCallback | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onToggle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onToggle?: SelectCallback | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PopoverProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property arrowOffsetLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              arrowOffsetLeft?: number | string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property arrowOffsetTop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                arrowOffsetTop?: number | string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property bsSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bsSize?: Sizes | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property bsStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bsStyle?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property placement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        placement?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property positionLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          positionLeft?: number | string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property positionTop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            positionTop?: number | string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              title?: React.ReactNode | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ProgressBarProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property active

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  active?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property bsSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bsSize?: Sizes | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property bsStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bsStyle?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property interpolatedClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interpolatedClass?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            label?: React.ReactNode | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property max

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              max?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property min

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                min?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property now

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  now?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property srOnly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    srOnly?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property striped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      striped?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RadioProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RadioProps extends React.HTMLProps<Radio> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            disabled?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property inline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              inline?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property inputRef

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property validationState

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ResponsiveEmbedProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ResponsiveEmbedProps extends React.HTMLProps<ResponsiveEmbed> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property a16by9

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      a16by9?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property a4by3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        a4by3?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RowProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RowProps extends React.HTMLProps<Row> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property componentClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              componentClass?: React.ElementType | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SafeAnchorProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SafeAnchorProps extends React.HTMLProps<SafeAnchor> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property componentClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  componentClass?: React.ElementType | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    disabled?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property href

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      href?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onClick?: React.MouseEventHandler<{}> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property role

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          role?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property bsStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bsStyle?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property dropdownTitle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dropdownTitle?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property dropup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        dropup?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property pullRight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            pullRight?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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) | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TabContentProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TabContentProps extends React.HTMLProps<TabContent> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property animation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          animation?: boolean | React.ElementType | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property componentClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              componentClass?: React.ElementType | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property mountOnEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mountOnEnter?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property unmountOnExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  unmountOnExit?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TableProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TableProps extends React.HTMLProps<Table> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property bordered

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bordered?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property condensed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          condensed?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fill

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fill?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property hover

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hover?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property responsive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                responsive?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property striped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  striped?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TabPaneProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property 'aria-labelledby'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'aria-labelledby'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property animation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property eventKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            eventKey?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property mountOnEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mountOnEnter?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property unmountOnExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                unmountOnExit?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TabProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property 'aria-labelledby'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'aria-labelledby'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property animation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      animation?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property eventKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          eventKey?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property tabClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tabClassName?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              title?: React.ReactNode | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property unmountOnExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                unmountOnExit?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TabsProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TabsProps extends React.HTMLProps<Tabs> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property activeKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    activeKey?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property animation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      animation?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property bsStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bsStyle?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property defaultActiveKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          defaultActiveKey?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property justified

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            justified?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property mountOnEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mountOnEnter?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onSelect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onSelect?: SelectCallback | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property paneWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  paneWidth?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    position?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tabWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tabWidth?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property unmountOnExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        unmountOnExit?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ThumbnailProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ThumbnailProps extends React.HTMLProps<Thumbnail> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property bsSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bsSize?: Sizes | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property bsStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bsStyle?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ToggleButtonProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ToggleButtonProps extends React.HTMLProps<ToggleButton> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property checked

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  checked?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TooltipProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TooltipProps extends React.HTMLProps<Tooltip> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property arrowOffsetLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arrowOffsetLeft?: number | string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property arrowOffsetTop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            arrowOffsetTop?: number | string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property bsClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bsClass?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property bsSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bsSize?: Sizes | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property bsStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bsStyle?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property placement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    placement?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property positionLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      positionLeft?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property positionTop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        positionTop?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property bsSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bsSize?: Sizes | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property bsStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bsStyle?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CarouselProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CarouselProps = Omit<React.HTMLProps<Carousel>, 'wrap'> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                activeIndex?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bsSize?: Sizes | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bsStyle?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                controls?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                defaultActiveIndex?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                direction?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                indicators?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interval?: number | null | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                nextIcon?: React.ReactNode | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onSelect?: SelectCallback | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                // TODO: Add more specific type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onSlideEnd?: Function | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                pauseOnHover?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                prevIcon?: React.ReactNode | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                slide?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                wrap?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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>