reactstrap

  • Version 9.2.2
  • Published
  • 2.19 MB
  • 6 dependencies
  • MIT license

Install

npm i reactstrap
yarn add reactstrap
pnpm add reactstrap

Overview

React Bootstrap components

Index

Classes

Interfaces

Namespaces

Classes

class Accordion

class Accordion extends React.Component<AccordionProps> {}

    class AccordionBody

    class AccordionBody extends React.Component<AccordionBodyProps> {}

      class AccordionHeader

      class AccordionHeader extends React.Component<AccordionHeaderProps> {}

        class AccordionItem

        class AccordionItem extends React.Component<AccordionItemProps> {}

          class Alert

          class Alert extends React.Component<AlertProps> {}

            class Badge

            class Badge extends React.Component<BadgeProps> {}
              class Breadcrumb extends React.Component<BreadcrumbProps> {}
                class BreadcrumbItem extends React.Component<BreadcrumbItemProps> {}

                  class Button

                  class Button extends React.Component<ButtonProps> {}

                    class ButtonDropdown

                    class ButtonDropdown extends React.Component<DropdownProps> {}

                      class ButtonGroup

                      class ButtonGroup extends React.Component<ButtonGroupProps> {}

                        class ButtonToggle

                        class ButtonToggle extends React.Component<ButtonToggleProps> {}

                          class ButtonToolbar

                          class ButtonToolbar extends React.Component<ButtonToolbarProps> {}

                            class Card

                            class Card extends React.Component<CardProps> {}

                              class CardBody

                              class CardBody extends React.Component<CardBodyProps> {}

                                class CardColumns

                                class CardColumns extends React.Component<CardColumnsProps> {}

                                  class CardDeck

                                  class CardDeck extends React.Component<CardDeckProps> {}

                                    class CardFooter

                                    class CardFooter extends React.Component<CardFooterProps> {}

                                      class CardGroup

                                      class CardGroup extends React.Component<CardGroupProps> {}

                                        class CardHeader

                                        class CardHeader extends React.Component<CardHeaderProps> {}

                                          class CardImg

                                          class CardImg extends React.Component<CardImgProps> {}

                                            class CardImgOverlay

                                            class CardImgOverlay extends React.Component<CardImgOverlayProps> {}
                                              class CardLink extends React.Component<CardLinkProps> {}

                                                class CardSubtitle

                                                class CardSubtitle extends React.Component<CardSubtitleProps> {}

                                                  class CardText

                                                  class CardText extends React.Component<CardTextProps> {}

                                                    class CardTitle

                                                    class CardTitle extends React.Component<CardTitleProps> {}
                                                      class Carousel extends React.Component<CarouselProps> {}

                                                        class CarouselCaption

                                                        class CarouselCaption extends React.Component<CarouselCaptionProps> {}

                                                          class CarouselControl

                                                          class CarouselControl extends React.Component<CarouselControlProps> {}

                                                            class CarouselIndicators

                                                            class CarouselIndicators extends React.Component<CarouselIndicatorsProps> {}

                                                              class CarouselItem

                                                              class CarouselItem extends React.Component<CarouselItemProps> {}

                                                                class CloseButton

                                                                class CloseButton extends React.Component<CloseButtonProps> {}

                                                                  class Col

                                                                  class Col extends React.Component<ColProps> {}

                                                                    class Collapse

                                                                    class Collapse extends React.Component<CollapseProps> {}

                                                                      class Container

                                                                      class Container extends React.Component<ContainerProps> {}
                                                                        class Dropdown extends React.Component<DropdownProps> {}
                                                                          class DropdownItem extends React.Component<DropdownItemProps> {}
                                                                            class DropdownMenu extends React.Component<DropdownMenuProps> {}
                                                                              class DropdownToggle extends React.Component<DropdownToggleProps> {}

                                                                                class Fade

                                                                                class Fade extends React.Component<FadeProps> {}

                                                                                  class Form

                                                                                  class Form extends React.Component<FormProps> {}

                                                                                    class FormFeedback

                                                                                    class FormFeedback extends React.Component<FormFeedbackProps> {}

                                                                                      class FormGroup

                                                                                      class FormGroup extends React.Component<FormGroupProps> {}

                                                                                        class FormText

                                                                                        class FormText extends React.Component<FormTextProps> {}

                                                                                          class Input

                                                                                          class Input extends React.Component<InputProps> {}

                                                                                            class InputGroup

                                                                                            class InputGroup extends React.Component<InputGroupProps> {}

                                                                                              class InputGroupText

                                                                                              class InputGroupText extends React.Component<InputGroupTextProps> {}

                                                                                                class Label

                                                                                                class Label extends React.Component<LabelProps> {}

                                                                                                  class List

                                                                                                  class List extends React.Component<ListProps> {}

                                                                                                    class ListGroup

                                                                                                    class ListGroup extends React.Component<ListGroupProps> {}

                                                                                                      class ListGroupItem

                                                                                                      class ListGroupItem extends React.Component<ListGroupItemProps> {}

                                                                                                        class ListGroupItemHeading

                                                                                                        class ListGroupItemHeading extends React.Component<ListGroupItemHeadingProps> {}

                                                                                                          class ListGroupItemText

                                                                                                          class ListGroupItemText extends React.Component<ListGroupItemTextProps> {}

                                                                                                            class ListInlineItem

                                                                                                            class ListInlineItem extends React.Component<ListInlineItemProps> {}

                                                                                                              class Media

                                                                                                              class Media extends React.Component<MediaProps> {}
                                                                                                                class Modal extends React.Component<ModalProps> {}

                                                                                                                  class ModalBody

                                                                                                                  class ModalBody extends React.Component<ModalBodyProps> {}

                                                                                                                    class ModalFooter

                                                                                                                    class ModalFooter extends React.Component<ModalFooterProps> {}

                                                                                                                      class ModalHeader

                                                                                                                      class ModalHeader extends React.Component<ModalHeaderProps> {}
                                                                                                                        class Nav extends React.Component<NavProps> {}
                                                                                                                          class Navbar extends React.Component<NavbarProps> {}
                                                                                                                            class NavbarBrand extends React.Component<NavbarBrandProps> {}
                                                                                                                              class NavbarText extends React.Component<NavbarTextProps> {}
                                                                                                                                class NavbarToggler extends React.Component<NavbarTogglerProps> {}
                                                                                                                                  class NavItem extends React.Component<NavItemProps> {}
                                                                                                                                    class NavLink extends React.Component<NavLinkProps> {}

                                                                                                                                      class Offcanvas

                                                                                                                                      class Offcanvas extends React.Component<OffcanvasProps> {}

                                                                                                                                        class OffcanvasBody

                                                                                                                                        class OffcanvasBody extends React.Component<OffcanvasBodyProps> {}

                                                                                                                                          class OffcanvasHeader

                                                                                                                                          class OffcanvasHeader extends React.Component<OffcanvasHeaderProps> {}

                                                                                                                                            class Pagination

                                                                                                                                            class Pagination extends React.Component<PaginationProps> {}

                                                                                                                                              class PaginationItem

                                                                                                                                              class PaginationItem extends React.Component<PaginationItemProps> {}
                                                                                                                                                class PaginationLink extends React.Component<PaginationLinkProps> {}

                                                                                                                                                  class Placeholder

                                                                                                                                                  class Placeholder extends React.Component<PlaceholderProps> {}

                                                                                                                                                    class PlaceholderButton

                                                                                                                                                    class PlaceholderButton extends React.Component<PlaceholderButtonProps> {}

                                                                                                                                                      class Popover

                                                                                                                                                      class Popover extends React.Component<PopoverProps> {}

                                                                                                                                                        class PopoverBody

                                                                                                                                                        class PopoverBody extends React.Component<PopoverBodyProps> {}

                                                                                                                                                          class PopoverHeader

                                                                                                                                                          class PopoverHeader extends React.Component<PopoverHeaderProps> {}

                                                                                                                                                            class Progress

                                                                                                                                                            class Progress extends React.Component<ProgressProps> {}

                                                                                                                                                              class Row

                                                                                                                                                              class Row extends React.Component<RowProps> {}

                                                                                                                                                                class Spinner

                                                                                                                                                                class Spinner extends React.Component<SpinnerProps> {}

                                                                                                                                                                  class TabContent

                                                                                                                                                                  class TabContent extends React.Component<TabContentProps> {}

                                                                                                                                                                    class Table

                                                                                                                                                                    class Table extends React.Component<TableProps> {}

                                                                                                                                                                      class TabPane

                                                                                                                                                                      class TabPane extends React.Component<TabPaneProps> {}

                                                                                                                                                                        class Tag

                                                                                                                                                                        class Tag extends React.Component<TagProps> {}

                                                                                                                                                                          class Toast

                                                                                                                                                                          class Toast extends React.Component<ToastProps> {}

                                                                                                                                                                            class ToastBody

                                                                                                                                                                            class ToastBody extends React.Component<ToastBodyProps> {}

                                                                                                                                                                              class ToastHeader

                                                                                                                                                                              class ToastHeader extends React.Component<ToastHeaderProps> {}

                                                                                                                                                                                class Tooltip

                                                                                                                                                                                class Tooltip extends React.Component<TooltipProps> {}

                                                                                                                                                                                  class UncontrolledAccordion

                                                                                                                                                                                  class UncontrolledAccordion extends React.Component<UncontrolledAccordionProps> {}

                                                                                                                                                                                    class UncontrolledAlert

                                                                                                                                                                                    class UncontrolledAlert extends React.Component<UncontrolledAlertProps> {}

                                                                                                                                                                                      class UncontrolledButtonDropdown

                                                                                                                                                                                      class UncontrolledButtonDropdown extends React.Component<UncontrolledButtonDropdownProps> {}

                                                                                                                                                                                        class UncontrolledCarousel

                                                                                                                                                                                        class UncontrolledCarousel extends React.Component<UncontrolledCarouselProps> {}

                                                                                                                                                                                          class UncontrolledCollapse

                                                                                                                                                                                          class UncontrolledCollapse extends React.Component<UncontrolledCollapseProps> {}

                                                                                                                                                                                            class UncontrolledDropdown

                                                                                                                                                                                            class UncontrolledDropdown extends React.Component<UncontrolledDropdownProps> {}

                                                                                                                                                                                              class UncontrolledPopover

                                                                                                                                                                                              class UncontrolledPopover extends React.Component<UncontrolledPopoverProps> {}

                                                                                                                                                                                                class UncontrolledTooltip

                                                                                                                                                                                                class UncontrolledTooltip extends React.Component<UncontrolledTooltipProps> {}

                                                                                                                                                                                                  Interfaces

                                                                                                                                                                                                  interface AccordionBodyProps

                                                                                                                                                                                                  interface AccordionBodyProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                    property accordionId

                                                                                                                                                                                                    accordionId: string;

                                                                                                                                                                                                      property cssModule

                                                                                                                                                                                                      cssModule?: CSSModule;

                                                                                                                                                                                                        property innerRef

                                                                                                                                                                                                        innerRef?: React.Ref<HTMLElement>;

                                                                                                                                                                                                          property tag

                                                                                                                                                                                                          tag?: React.ElementType;

                                                                                                                                                                                                            interface AccordionHeaderProps

                                                                                                                                                                                                            interface AccordionHeaderProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                              property cssModule

                                                                                                                                                                                                              cssModule?: CSSModule;

                                                                                                                                                                                                                property innerRef

                                                                                                                                                                                                                innerRef?: React.Ref<HTMLElement>;

                                                                                                                                                                                                                  property tag

                                                                                                                                                                                                                  tag?: React.ElementType;

                                                                                                                                                                                                                    property targetId

                                                                                                                                                                                                                    targetId: string;

                                                                                                                                                                                                                      interface AccordionItemProps

                                                                                                                                                                                                                      interface AccordionItemProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                        property cssModule

                                                                                                                                                                                                                        cssModule?: CSSModule;

                                                                                                                                                                                                                          property innerRef

                                                                                                                                                                                                                          innerRef?: React.Ref<HTMLElement>;

                                                                                                                                                                                                                            property tag

                                                                                                                                                                                                                            tag?: React.ElementType;

                                                                                                                                                                                                                              interface AccordionProps

                                                                                                                                                                                                                              interface AccordionProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                property cssModule

                                                                                                                                                                                                                                cssModule?: CSSModule;

                                                                                                                                                                                                                                  property flush

                                                                                                                                                                                                                                  flush?: boolean;

                                                                                                                                                                                                                                    property innerRef

                                                                                                                                                                                                                                    innerRef?: React.Ref<HTMLElement>;

                                                                                                                                                                                                                                      property open

                                                                                                                                                                                                                                      open: string | string[];

                                                                                                                                                                                                                                        property tag

                                                                                                                                                                                                                                        tag?: React.ElementType;

                                                                                                                                                                                                                                          property toggle

                                                                                                                                                                                                                                          toggle: (targetId: string) => void;

                                                                                                                                                                                                                                            interface AlertProps

                                                                                                                                                                                                                                            interface AlertProps extends UncontrolledAlertProps {}

                                                                                                                                                                                                                                              property isOpen

                                                                                                                                                                                                                                              isOpen?: boolean;

                                                                                                                                                                                                                                                property toggle

                                                                                                                                                                                                                                                toggle?: React.MouseEventHandler<any>;

                                                                                                                                                                                                                                                  interface BadgeProps

                                                                                                                                                                                                                                                  interface BadgeProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                    property color

                                                                                                                                                                                                                                                    color?: string;

                                                                                                                                                                                                                                                      property cssModule

                                                                                                                                                                                                                                                      cssModule?: CSSModule;

                                                                                                                                                                                                                                                        property innerRef

                                                                                                                                                                                                                                                        innerRef?: React.Ref<HTMLElement>;

                                                                                                                                                                                                                                                          property pill

                                                                                                                                                                                                                                                          pill?: boolean;

                                                                                                                                                                                                                                                            property tag

                                                                                                                                                                                                                                                            tag?: React.ElementType;

                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                              [key: string]: any;
                                                                                                                                                                                                                                                                interface BreadcrumbItemProps extends React.HTMLAttributes<HTMLElement> {}
                                                                                                                                                                                                                                                                  active?: boolean;
                                                                                                                                                                                                                                                                    cssModule?: CSSModule;
                                                                                                                                                                                                                                                                      tag?: React.ElementType;
                                                                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                                                                          interface BreadcrumbProps extends React.HTMLAttributes<HTMLElement> {}
                                                                                                                                                                                                                                                                            cssModule?: CSSModule;
                                                                                                                                                                                                                                                                              listClassName?: string;
                                                                                                                                                                                                                                                                                listTag?: React.ElementType;
                                                                                                                                                                                                                                                                                  tag?: React.ElementType;
                                                                                                                                                                                                                                                                                    [key: string]: any;

                                                                                                                                                                                                                                                                                      interface ButtonDropdownProps

                                                                                                                                                                                                                                                                                      interface DropdownProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                        property a11y

                                                                                                                                                                                                                                                                                        a11y?: boolean;

                                                                                                                                                                                                                                                                                          property active

                                                                                                                                                                                                                                                                                          active?: boolean;

                                                                                                                                                                                                                                                                                            property addonType

                                                                                                                                                                                                                                                                                            addonType?: boolean | 'prepend' | 'append';

                                                                                                                                                                                                                                                                                              property cssModule

                                                                                                                                                                                                                                                                                              cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                property direction

                                                                                                                                                                                                                                                                                                direction?: Direction;

                                                                                                                                                                                                                                                                                                  property disabled

                                                                                                                                                                                                                                                                                                  disabled?: boolean;

                                                                                                                                                                                                                                                                                                    property group

                                                                                                                                                                                                                                                                                                    group?: boolean;

                                                                                                                                                                                                                                                                                                      property inNavbar

                                                                                                                                                                                                                                                                                                      inNavbar?: boolean;

                                                                                                                                                                                                                                                                                                        property isOpen

                                                                                                                                                                                                                                                                                                        isOpen?: boolean;

                                                                                                                                                                                                                                                                                                          property menuRole

                                                                                                                                                                                                                                                                                                          menuRole?: boolean | string;

                                                                                                                                                                                                                                                                                                            property nav

                                                                                                                                                                                                                                                                                                            nav?: boolean;

                                                                                                                                                                                                                                                                                                              property setActiveFromChild

                                                                                                                                                                                                                                                                                                              setActiveFromChild?: boolean;

                                                                                                                                                                                                                                                                                                                property size

                                                                                                                                                                                                                                                                                                                size?: string;

                                                                                                                                                                                                                                                                                                                  property tag

                                                                                                                                                                                                                                                                                                                  tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                    property toggle

                                                                                                                                                                                                                                                                                                                    toggle?: React.KeyboardEventHandler<any> | React.MouseEventHandler<any>;

                                                                                                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                                                                                                      [key: string]: any;

                                                                                                                                                                                                                                                                                                                        interface ButtonGroupProps

                                                                                                                                                                                                                                                                                                                        interface ButtonGroupProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                          property cssModule

                                                                                                                                                                                                                                                                                                                          cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                            property size

                                                                                                                                                                                                                                                                                                                            size?: string;

                                                                                                                                                                                                                                                                                                                              property tag

                                                                                                                                                                                                                                                                                                                              tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                property vertical

                                                                                                                                                                                                                                                                                                                                vertical?: boolean;

                                                                                                                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                                                                                                                  [key: string]: any;

                                                                                                                                                                                                                                                                                                                                    interface ButtonProps

                                                                                                                                                                                                                                                                                                                                    interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {}

                                                                                                                                                                                                                                                                                                                                      property active

                                                                                                                                                                                                                                                                                                                                      active?: boolean;

                                                                                                                                                                                                                                                                                                                                        property block

                                                                                                                                                                                                                                                                                                                                        block?: boolean;

                                                                                                                                                                                                                                                                                                                                          property close

                                                                                                                                                                                                                                                                                                                                          close?: boolean;

                                                                                                                                                                                                                                                                                                                                            property color

                                                                                                                                                                                                                                                                                                                                            color?: string;

                                                                                                                                                                                                                                                                                                                                              property cssModule

                                                                                                                                                                                                                                                                                                                                              cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                property innerRef

                                                                                                                                                                                                                                                                                                                                                innerRef?: React.Ref<HTMLButtonElement>;

                                                                                                                                                                                                                                                                                                                                                  property outline

                                                                                                                                                                                                                                                                                                                                                  outline?: boolean;

                                                                                                                                                                                                                                                                                                                                                    property size

                                                                                                                                                                                                                                                                                                                                                    size?: string;

                                                                                                                                                                                                                                                                                                                                                      property tag

                                                                                                                                                                                                                                                                                                                                                      tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                          interface ButtonToggleProps

                                                                                                                                                                                                                                                                                                                                                          interface ButtonToggleProps
                                                                                                                                                                                                                                                                                                                                                          extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'defaultValue'> {}

                                                                                                                                                                                                                                                                                                                                                            property defaultValue

                                                                                                                                                                                                                                                                                                                                                            defaultValue?: boolean;

                                                                                                                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                                                                                                                              [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                interface ButtonToolbarProps

                                                                                                                                                                                                                                                                                                                                                                interface ButtonToolbarProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                  property cssModule

                                                                                                                                                                                                                                                                                                                                                                  cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                    property tag

                                                                                                                                                                                                                                                                                                                                                                    tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                        interface CardBodyProps

                                                                                                                                                                                                                                                                                                                                                                        interface CardBodyProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                          property cssModule

                                                                                                                                                                                                                                                                                                                                                                          cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                            property innerRef

                                                                                                                                                                                                                                                                                                                                                                            innerRef?: React.Ref<HTMLElement>;

                                                                                                                                                                                                                                                                                                                                                                              property tag

                                                                                                                                                                                                                                                                                                                                                                              tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                  interface CardColumnsProps

                                                                                                                                                                                                                                                                                                                                                                                  interface CardColumnsProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                    property cssModule

                                                                                                                                                                                                                                                                                                                                                                                    cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                      property tag

                                                                                                                                                                                                                                                                                                                                                                                      tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                          interface CardDeckProps

                                                                                                                                                                                                                                                                                                                                                                                          interface CardDeckProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                            property cssModule

                                                                                                                                                                                                                                                                                                                                                                                            cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                              property tag

                                                                                                                                                                                                                                                                                                                                                                                              tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                  interface CardFooterProps

                                                                                                                                                                                                                                                                                                                                                                                                  interface CardFooterProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                    property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                    cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                      property tag

                                                                                                                                                                                                                                                                                                                                                                                                      tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                          interface CardGroupProps

                                                                                                                                                                                                                                                                                                                                                                                                          interface CardGroupProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                            property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                            cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                              property tag

                                                                                                                                                                                                                                                                                                                                                                                                              tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                  interface CardHeaderProps

                                                                                                                                                                                                                                                                                                                                                                                                                  interface CardHeaderProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                    property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                    cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                      property tag

                                                                                                                                                                                                                                                                                                                                                                                                                      tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                          interface CardImgOverlayProps

                                                                                                                                                                                                                                                                                                                                                                                                                          interface CardImgOverlayProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                            property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                            cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                              property tag

                                                                                                                                                                                                                                                                                                                                                                                                                              tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CardImgProps

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CardImgProps extends React.ImgHTMLAttributes<HTMLImageElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                    property bottom

                                                                                                                                                                                                                                                                                                                                                                                                                                    bottom?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                      cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                        tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property top

                                                                                                                                                                                                                                                                                                                                                                                                                                          top?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                            index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                            [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CardLinkProps

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CardLinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property innerRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                  innerRef?: React.Ref<HTMLAnchorElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                    tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CardProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CardProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property body

                                                                                                                                                                                                                                                                                                                                                                                                                                                          body?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property color

                                                                                                                                                                                                                                                                                                                                                                                                                                                            color?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                              cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property innerRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                innerRef?: React.Ref<HTMLElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property inverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  inverse?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property outline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    outline?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CardSubtitleProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CardSubtitleProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CardTextProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CardTextProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CardTitleProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CardTitleProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CarouselCaptionProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CarouselCaptionProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property captionHeader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    captionHeader?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property captionText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      captionText: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CarouselControlProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CarouselControlProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property direction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                direction: 'prev' | 'next';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property directionText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  directionText?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onClickHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onClickHandler: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CarouselIndicatorsProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CarouselIndicatorsProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property activeIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          activeIndex: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property items

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              items: object[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onClickHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onClickHandler: (idx: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CarouselItemProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface CarouselItemProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property in

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        in?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onEnter?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onEntered

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onEntered?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onEntering

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onEntering?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onExit?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onExited

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onExited?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onExiting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onExiting?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property slide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      slide?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CarouselProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface CarouselProps extends CommonCarouselProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property next

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              next: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property previous

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                previous: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CloseButtonProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CloseButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property active

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    active?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property variant

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variant?: 'white' | 'black';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CollapseProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CollapseProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property delay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              delay?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              show: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hide: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property horizontal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                horizontal?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property innerRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  innerRef?: React.Ref<HTMLElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property isOpen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isOpen?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property navbar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      navbar?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onClosed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onClosed?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onEntered

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onEntered?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onEntering

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onEntering?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onExit?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onExited

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onExited?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onExiting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onExiting?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onOpened

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onOpened?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ColProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ColProps extends React.HTMLAttributes<HTMLDivElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property lg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              lg?: ColumnProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property md

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                md?: ColumnProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property sm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sm?: ColumnProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property widths

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      widths?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property xl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        xl?: ColumnProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property xs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          xs?: ColumnProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property xxl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            xxl?: ColumnProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ContainerProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ContainerProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property fluid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fluid?: boolean | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DropdownItemProps extends React.HTMLAttributes<HTMLElement> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            active?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cssModule?: CSSModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  divider?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    header?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      href?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tag?: React.ElementType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          text?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            toggle?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DropdownMenuProps extends React.HTMLAttributes<HTMLElement> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  container?: string | HTMLElement | React.RefObject<HTMLElement>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cssModule?: CSSModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dark?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        flip?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          modifiers?: Modifier<string, any>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            persist?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              right?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                strategy?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tag?: React.ElementType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    updateOnSelect?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface DropdownProps extends React.HTMLAttributes<HTMLElement> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          a11y?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            active?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              addonType?: boolean | 'prepend' | 'append';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cssModule?: CSSModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  direction?: Direction;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      group?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        inNavbar?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isOpen?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            menuRole?: boolean | string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nav?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setActiveFromChild?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  size?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tag?: React.ElementType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      toggle?: React.KeyboardEventHandler<any> | React.MouseEventHandler<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DropdownToggleProps extends React.HTMLAttributes<HTMLElement> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-haspopup'?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              'data-toggle'?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                caret?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  color?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cssModule?: CSSModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        nav?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          outline?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            size?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              split?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tag?: React.ElementType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface FadeProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface FadeProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property baseClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      baseClass?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property baseClassIn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        baseClassIn?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property in

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            in?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property innerRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              innerRef?: React.Ref<HTMLElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onEnter?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onLeave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onLeave?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property transitionAppear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      transitionAppear?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property transitionAppearTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        transitionAppearTimeout?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property transitionEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          transitionEnter?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property transitionEnterTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            transitionEnterTimeout?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property transitionLeave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              transitionLeave?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property transitionLeaveTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                transitionLeaveTimeout?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface FormFeedbackProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface FormFeedbackProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tag?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tooltip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tooltip?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property valid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            valid?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FormGroupProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FormGroupProps extends React.HTMLAttributes<HTMLDivElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property check

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  check?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      disabled?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property floating

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        floating?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property inline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          inline?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property noMargin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            noMargin?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property row

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              row?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property switch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                switch?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface FormProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface FormProps extends React.FormHTMLAttributes<HTMLFormElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property innerRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          innerRef?: React.Ref<HTMLFormElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FormTextProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FormTextProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property color

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  color?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property inline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      inline?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface InputGroupProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface InputGroupProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                size?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface InputGroupTextProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface InputGroupTextProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface InputProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property addon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                addon?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property bsSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bsSize?: 'lg' | 'sm';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property innerRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      innerRef?: React.Ref<HTMLInputElement | HTMLTextAreaElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property invalid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        invalid?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property plaintext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          plaintext?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type?: InputType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property valid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                valid?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface LabelProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface LabelProps extends React.LabelHTMLAttributes<HTMLLabelElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property check

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      check?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          disabled?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property for

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            for?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property hidden

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hidden?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property lg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                lg?: ColumnProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property md

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  md?: ColumnProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    size?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property sm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sm?: ColumnProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property widths

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          widths?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property xl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            xl?: ColumnProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property xs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              xs?: ColumnProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property xxl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                xxl?: ColumnProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ListGroupItemHeadingProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ListGroupItemHeadingProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ListGroupItemProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ListGroupItemProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property action

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              action?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property active

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                active?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property color

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  color?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      disabled?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property href

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        href?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ListGroupItemTextProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ListGroupItemTextProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ListGroupProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ListGroupProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property flush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          flush?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property horizontal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            horizontal?: boolean | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property numbered

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              numbered?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ListInlineItemProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ListInlineItemProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ListProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ListProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MediaProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MediaProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property alt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        alt?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property body

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          body?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property bottom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bottom?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property heading

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                heading?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property href

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  href?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property left

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    left?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property list

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      list?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property middle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        middle?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          object?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property right

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            right?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property src

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              src?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property top

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  top?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ModalBodyProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ModalBodyProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ModalFooterProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ModalFooterProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ModalHeaderProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ModalHeaderProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property toggle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            toggle?: React.MouseEventHandler<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property wrapTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              wrapTag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ModalProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ModalProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property autoFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    autoFocus?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property backdrop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      backdrop?: boolean | 'static';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property backdropClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        backdropClassName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property backdropTransition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          backdropTransition?: FadeProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property centered

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            centered?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property container

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              container?: string | HTMLElement | React.RefObject<HTMLElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property contentClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                contentClassName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property external

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    external?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property fade

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fade?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property fullscreen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fullscreen?: boolean | 'sm' | 'md' | 'lg' | 'xl';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property innerRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          innerRef?: React.Ref<HTMLElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isOpen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isOpen?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property keyboard

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              keyboard?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property labelledBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                labelledBy?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property modalClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  modalClassName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property modalTransition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    modalTransition?: FadeProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onClosed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onClosed?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onEnter?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onExit?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onOpened

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onOpened?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property returnFocusAfterClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              returnFocusAfterClose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property scrollable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scrollable?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  size?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property toggle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toggle?: React.KeyboardEventHandler<any> | React.MouseEventHandler<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property trapFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      trapFocus?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property unmountOnClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        unmountOnClose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property wrapClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          wrapClassName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property zIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            zIndex?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface NavbarBrandProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cssModule?: CSSModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tag?: React.ElementType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface NavbarProps extends React.HTMLAttributes<HTMLElement> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          color?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            container?: boolean | 'fluid' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cssModule?: CSSModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                dark?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  expand?: boolean | string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fixed?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      full?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        light?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sticky?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tag?: React.ElementType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface NavbarTextProps extends React.HTMLAttributes<HTMLElement> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cssModule?: CSSModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tag?: React.ElementType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface NavbarTogglerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cssModule?: CSSModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tag?: React.ElementType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface NavItemProps extends React.HTMLAttributes<HTMLElement> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  active?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cssModule?: CSSModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tag?: React.ElementType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface NavLinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            active?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cssModule?: CSSModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  innerRef?: React.Ref<HTMLAnchorElement>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tag?: React.ElementType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface NavProps extends React.HTMLAttributes<HTMLUListElement> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          card?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cssModule?: CSSModule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fill?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                horizontal?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  justified?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    navbar?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pills?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tabs?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tag?: React.ElementType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            vertical?: boolean | string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface OffcanvasBodyProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface OffcanvasBodyProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface OffcanvasHeaderProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface OffcanvasHeaderProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property toggle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toggle?: React.MouseEventHandler<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property wrapTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                wrapTag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface OffcanvasProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface OffcanvasProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property autoFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      autoFocus?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property backdrop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        backdrop?: boolean | 'static';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property backdropClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          backdropClassName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property backdropTransition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            backdropTransition?: FadeProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property container

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              container?: string | HTMLElement | React.RefObject<HTMLElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property contentClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                contentClassName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property direction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    direction?: Direction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property fade

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fade?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property innerRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        innerRef?: React.Ref<HTMLElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property isOpen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isOpen?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property keyboard

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            keyboard?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property labelledBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              labelledBy?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property offcanvasClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                offcanvasClassName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property offcanvasTransition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  offcanvasTransition?: FadeProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onClosed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onClosed?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onEnter?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onExit?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onOpened

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onOpened?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property returnFocusAfterClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            returnFocusAfterClose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property scrollable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scrollable?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property toggle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                toggle?: React.KeyboardEventHandler<any> | React.MouseEventHandler<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property trapFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  trapFocus?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property unmountOnClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    unmountOnClose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property wrapClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      wrapClassName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property zIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        zIndex?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PaginationItemProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PaginationItemProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property active

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              active?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  disabled?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PaginationLinkProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PaginationLinkProps
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        extends React.AnchorHTMLAttributes<HTMLAnchorElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property 'aria-label'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'aria-label'?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property first

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              first?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property last

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                last?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property next

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  next?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property previous

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    previous?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PaginationProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PaginationProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property 'aria-label'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'aria-label'?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property listClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                listClassName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property listTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  listTag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    size?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PlaceholderButtonProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PlaceholderButtonProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property color

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            color?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property outline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                outline?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  size?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PlaceholderProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PlaceholderProps extends React.HTMLAttributes<HTMLElement> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property animation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          animation?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            className?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property color

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              color?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property cssModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cssModule?: CSSModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property innerRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  innerRef?: React.Ref<HTMLElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    size?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tag?: React.ElementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property widths

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        widths?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PopoverBodyProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PopoverBodyProps extends React.HTMLAttributes<HTMLElement