@types/react-bootstrap

  • Version 0.32.36
  • Published
  • 72.6 kB
  • 1 dependency
  • MIT license

Install

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

Overview

TypeScript definitions for react-bootstrap

Index

Interfaces

Type Aliases

Namespaces

Interfaces

interface AccordionProps

interface AccordionProps extends React.HTMLProps<Accordion> {}

    property bsSize

    bsSize?: Sizes | 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 extends React.RefAttributes<BreadcrumbItem> {}
                                        active?: boolean | undefined;
                                          children?: React.ReactNode;
                                            href?: string | 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?: 'top' | 'right' | 'bottom' | 'left' | 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 extends React.RefAttributes<OverlayTrigger> {}

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