Added reactstrap v7 files

types/reactstrap/v7/index.d.ts

@@ -0,0 +1,267 @@
+// Type definitions for reactstrap 7.1
+// Project: https://github.com/reactstrap/reactstrap#readme
+// Definitions by: Ali Hammad Baig <https://github.com/alihammad>
+//                 Marco Falkenberg <https://github.com/mfal>
+//                 Danilo Barros <https://github.com/danilobjr>
+//                 FaithForHumans <https://github.com/FaithForHumans>
+//                 Tim Chen <https://github.com/timc13>
+//                 Pat Gaffney <https://github.com/patrickrgaffney>
+//                 Prabodh Tiwari <https://github.com/prabodht>
+//                 Georg Steinmetz <https://github.com/georg94>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.9
+
+export interface CSSModule {
+  [className: string]: string;
+}
+
+import { default as Alert_ } from './lib/Alert';
+export class Alert<T = {}> extends Alert_<T> {}
+export { AlertProps } from './lib/Alert';
+import { default as Badge_ } from './lib/Badge';
+export class Badge<T = {}> extends Badge_<T> {}
+export { BadgeProps } from './lib/Badge';
+import { default as Breadcrumb_ } from './lib/Breadcrumb';
+export class Breadcrumb<T = {}> extends Breadcrumb_<T> {}
+export { BreadcrumbProps } from './lib/Breadcrumb';
+import { default as BreadcrumbItem_ } from './lib/BreadcrumbItem';
+export class BreadcrumbItem<T = {}> extends BreadcrumbItem_<T> {}
+export { BreadcrumbItemProps } from './lib/BreadcrumbItem';
+import { default as Button_ } from './lib/Button';
+export class Button<T = {}> extends Button_<T> {}
+export { ButtonProps } from './lib/Button';
+import { default as ButtonDropdown_ } from './lib/ButtonDropdown';
+export class ButtonDropdown<T = {}> extends ButtonDropdown_<T> {}
+export { ButtonDropdownProps } from './lib/ButtonDropdown';
+import { default as ButtonGroup_ } from './lib/ButtonGroup';
+export class ButtonGroup<T = {}> extends ButtonGroup_<T> {}
+export { ButtonGroupProps } from './lib/ButtonGroup';
+import { default as ButtonToolbar_ } from './lib/ButtonToolbar';
+export class ButtonToolbar<T = {}> extends ButtonToolbar_<T> {}
+export { ButtonToolbarProps } from './lib/ButtonToolbar';
+import { default as Card_ } from './lib/Card';
+export class Card<T = {}> extends Card_<T> {}
+export { CardProps } from './lib/Card';
+import { default as CardBody_ } from './lib/CardBody';
+export class CardBody<T = {}> extends CardBody_<T> {}
+export { CardBodyProps } from './lib/CardBody';
+import { default as CardColumns_ } from './lib/CardColumns';
+export class CardColumns<T = {}> extends CardColumns_<T> {}
+export { CardColumnsProps } from './lib/CardColumns';
+import { default as CardDeck_ } from './lib/CardDeck';
+export class CardDeck<T = {}> extends CardDeck_<T> {}
+export { CardDeckProps } from './lib/CardDeck';
+import { default as CardFooter_ } from './lib/CardFooter';
+export class CardFooter<T = {}> extends CardFooter_<T> {}
+export { CardFooterProps } from './lib/CardFooter';
+import { default as CardGroup_ } from './lib/CardGroup';
+export class CardGroup<T = {}> extends CardGroup_<T> {}
+export { CardGroupProps } from './lib/CardGroup';
+import { default as CardHeader_ } from './lib/CardHeader';
+export class CardHeader<T = {}> extends CardHeader_<T> {}
+export { CardHeaderProps } from './lib/CardHeader';
+import { default as CardImg_ } from './lib/CardImg';
+export class CardImg<T = {}> extends CardImg_<T> {}
+export { CardImgProps } from './lib/CardImg';
+import { default as CardImgOverlay_ } from './lib/CardImgOverlay';
+export class CardImgOverlay<T = {}> extends CardImgOverlay_<T> {}
+export { CardImgOverlayProps } from './lib/CardImgOverlay';
+import { default as CardLink_ } from './lib/CardLink';
+export class CardLink<T = {}> extends CardLink_<T> {}
+export { CardLinkProps } from './lib/CardLink';
+import { default as CardSubtitle_ } from './lib/CardSubtitle';
+export class CardSubtitle<T = {}> extends CardSubtitle_<T> {}
+export { CardSubtitleProps } from './lib/CardSubtitle';
+import { default as CardText_ } from './lib/CardText';
+export class CardText<T = {}> extends CardText_<T> {}
+export { CardTextProps } from './lib/CardText';
+import { default as CardTitle_ } from './lib/CardTitle';
+export class CardTitle<T = {}> extends CardTitle_<T> {}
+export { CardTitleProps } from './lib/CardTitle';
+import { default as Carousel_ } from './lib/Carousel';
+export class Carousel<T = {}> extends Carousel_<T> {}
+export { CarouselProps } from './lib/Carousel';
+import { default as CarouselItem_ } from './lib/CarouselItem';
+export class CarouselItem<T = {}> extends CarouselItem_<T> {}
+export { CarouselItemProps } from './lib/CarouselItem';
+import { default as CarouselControl_ } from './lib/CarouselControl';
+export class CarouselControl<T = {}> extends CarouselControl_<T> {}
+export { CarouselControlProps } from './lib/CarouselControl';
+import { default as CarouselIndicators_ } from './lib/CarouselIndicators';
+export class CarouselIndicators<T = {}> extends CarouselIndicators_<T> {}
+export { CarouselIndicatorsProps } from './lib/CarouselIndicators';
+import { default as CarouselCaption_ } from './lib/CarouselCaption';
+export class CarouselCaption<T = {}> extends CarouselCaption_<T> {}
+export { CarouselCaptionProps } from './lib/CarouselCaption';
+import { default as Col_ } from './lib/Col';
+export class Col<T = {}> extends Col_<T> {}
+export { ColProps } from './lib/Col';
+import { default as Collapse_ } from './lib/Collapse';
+export class Collapse<T = {}> extends Collapse_<T> {}
+export { CollapseProps } from './lib/Collapse';
+import { default as Container_ } from './lib/Container';
+export class Container<T = {}> extends Container_<T> {}
+export { ContainerProps } from './lib/Container';
+import { default as CustomInput_ } from './lib/CustomInput';
+export class CustomInput<T = {}> extends CustomInput_<T> {}
+export { CustomInputProps } from './lib/CustomInput';
+import { default as Dropdown_ } from './lib/Dropdown';
+export class Dropdown<T = {}> extends Dropdown_<T> {}
+export { DropdownProps } from './lib/Dropdown';
+import { default as DropdownItem_ } from './lib/DropdownItem';
+export class DropdownItem<T = {}> extends DropdownItem_<T> {}
+export { DropdownItemProps } from './lib/DropdownItem';
+import { default as DropdownMenu_ } from './lib/DropdownMenu';
+export class DropdownMenu<T = {}> extends DropdownMenu_<T> {}
+export { DropdownMenuProps } from './lib/DropdownMenu';
+import { default as DropdownToggle_ } from './lib/DropdownToggle';
+export class DropdownToggle<T = {}> extends DropdownToggle_<T> {}
+export { DropdownToggleProps } from './lib/DropdownToggle';
+import { default as Fade_ } from './lib/Fade';
+export class Fade<T = {}> extends Fade_<T> {}
+export { FadeProps } from './lib/Fade';
+import { default as Form_ } from './lib/Form';
+export class Form<T = {}> extends Form_<T> {}
+export { FormProps } from './lib/Form';
+import { default as FormFeedback_ } from './lib/FormFeedback';
+export class FormFeedback<T = {}> extends FormFeedback_<T> {}
+export { FormFeedbackProps } from './lib/FormFeedback';
+import { default as FormGroup_ } from './lib/FormGroup';
+export class FormGroup<T = {}> extends FormGroup_<T> {}
+export { FormGroupProps } from './lib/FormGroup';
+import { default as FormText_ } from './lib/FormText';
+export class FormText<T = {}> extends FormText_<T> {}
+export { FormTextProps } from './lib/FormText';
+import { default as Input_ } from './lib/Input';
+export class Input<T = {}> extends Input_<T> {}
+export { InputProps } from './lib/Input';
+import { default as InputGroup_ } from './lib/InputGroup';
+export class InputGroup<T = {}> extends InputGroup_<T> {}
+export { InputGroupProps } from './lib/InputGroup';
+import { default as InputGroupAddon_ } from './lib/InputGroupAddon';
+export class InputGroupAddon<T = {}> extends InputGroupAddon_<T> {}
+export { InputGroupAddonProps } from './lib/InputGroupAddon';
+import { default as InputGroupButtonDropdown_ } from './lib/InputGroupButtonDropdown';
+export class InputGroupButtonDropdown<T = {}> extends InputGroupButtonDropdown_<T> {}
+export { InputGroupButtonDropdownProps } from './lib/InputGroupButtonDropdown';
+import { default as InputGroupText_ } from './lib/InputGroupText';
+export class InputGroupText<T = {}> extends InputGroupText_<T> {}
+export { InputGroupTextProps } from './lib/InputGroupText';
+import { default as Jumbotron_ } from './lib/Jumbotron';
+export class Jumbotron<T = {}> extends Jumbotron_<T> {}
+export { JumbotronProps } from './lib/Jumbotron';
+import { default as Label_ } from './lib/Label';
+export class Label<T = {}> extends Label_<T> {}
+export { LabelProps } from './lib/Label';
+import { default as ListGroup_ } from './lib/ListGroup';
+export class ListGroup<T = {}> extends ListGroup_<T> {}
+export { ListGroupProps } from './lib/ListGroup';
+import { default as ListGroupItem_ } from './lib/ListGroupItem';
+export class ListGroupItem<T = {}> extends ListGroupItem_<T> {}
+export { ListGroupItemProps } from './lib/ListGroupItem';
+import { default as ListGroupItemHeading_ } from './lib/ListGroupItemHeading';
+export class ListGroupItemHeading<T = {}> extends ListGroupItemHeading_<T> {}
+export { ListGroupItemHeadingProps } from './lib/ListGroupItemHeading';
+import { default as ListGroupItemText_ } from './lib/ListGroupItemText';
+export class ListGroupItemText<T = {}> extends ListGroupItemText_<T> {}
+export { ListGroupItemTextProps } from './lib/ListGroupItemText';
+import { default as Media_ } from './lib/Media';
+export class Media<T = {}> extends Media_<T> {}
+export { MediaProps } from './lib/Media';
+import { default as Modal_ } from './lib/Modal';
+export class Modal<T = {}> extends Modal_<T> {}
+export { ModalProps } from './lib/Modal';
+import { default as ModalBody_ } from './lib/ModalBody';
+export class ModalBody<T = {}> extends ModalBody_<T> {}
+export { ModalBodyProps } from './lib/ModalBody';
+import { default as ModalFooter_ } from './lib/ModalFooter';
+export class ModalFooter<T = {}> extends ModalFooter_<T> {}
+export { ModalFooterProps } from './lib/ModalFooter';
+import { default as ModalHeader_ } from './lib/ModalHeader';
+export class ModalHeader<T = {}> extends ModalHeader_<T> {}
+export { ModalHeaderProps } from './lib/ModalHeader';
+import { default as Nav_ } from './lib/Nav';
+export class Nav<T = {}> extends Nav_<T> {}
+export { NavProps } from './lib/Nav';
+import { default as Navbar_ } from './lib/Navbar';
+export class Navbar<T = {}> extends Navbar_<T> {}
+export { NavbarProps } from './lib/Navbar';
+import { default as NavbarBrand_ } from './lib/NavbarBrand';
+export class NavbarBrand<T = {}> extends NavbarBrand_<T> {}
+export { NavbarBrandProps } from './lib/NavbarBrand';
+import { default as NavbarToggler_ } from './lib/NavbarToggler';
+export class NavbarToggler<T = {}> extends NavbarToggler_<T> {}
+export { NavbarTogglerProps } from './lib/NavbarToggler';
+import { default as NavItem_ } from './lib/NavItem';
+export class NavItem<T = {}> extends NavItem_<T> {}
+export { NavItemProps } from './lib/NavItem';
+import { default as NavLink_ } from './lib/NavLink';
+export class NavLink<T = {}> extends NavLink_<T> {}
+export { NavLinkProps } from './lib/NavLink';
+import { default as Pagination_ } from './lib/Pagination';
+export class Pagination<T = {}> extends Pagination_<T> {}
+export { PaginationProps } from './lib/Pagination';
+import { default as PaginationItem_ } from './lib/PaginationItem';
+export class PaginationItem<T = {}> extends PaginationItem_<T> {}
+export { PaginationItemProps } from './lib/PaginationItem';
+import { default as PaginationLink_ } from './lib/PaginationLink';
+export class PaginationLink<T = {}> extends PaginationLink_<T> {}
+export { PaginationLinkProps } from './lib/PaginationLink';
+import { default as Popover_ } from './lib/Popover';
+export class Popover<T = {}> extends Popover_<T> {}
+export { PopoverProps } from './lib/Popover';
+import { default as PopoverBody_ } from './lib/PopoverBody';
+export class PopoverBody<T = {}> extends PopoverBody_<T> {}
+export { PopoverBodyProps } from './lib/PopoverBody';
+import { default as PopoverHeader_ } from './lib/PopoverHeader';
+export class PopoverHeader<T = {}> extends PopoverHeader_<T> {}
+export { PopoverHeaderProps } from './lib/PopoverHeader';
+import { default as Progress_ } from './lib/Progress';
+export class Progress<T = {}> extends Progress_<T> {}
+export { ProgressProps } from './lib/Progress';
+import { default as Row_ } from './lib/Row';
+export class Row<T = {}> extends Row_<T> {}
+export { RowProps } from './lib/Row';
+import { default as Spinner_ } from './lib/Spinner';
+export class Spinner<T = {}> extends Spinner_<T> {}
+export { SpinnerProps } from './lib/Spinner';
+import { default as TabContent_ } from './lib/TabContent';
+export class TabContent<T = {}> extends TabContent_<T> {}
+export { TabContentProps } from './lib/TabContent';
+import { default as Table_ } from './lib/Table';
+export class Table<T = {}> extends Table_<T> {}
+export { TableProps } from './lib/Table';
+import { default as TabPane_ } from './lib/TabPane';
+export class TabPane<T = {}> extends TabPane_<T> {}
+export { TabPaneProps } from './lib/TabPane';
+import { default as Tag_ } from './lib/Tag';
+export class Tag<T = {}> extends Tag_<T> {}
+export { TagProps } from './lib/Tag';
+import { default as Tooltip_ } from './lib/Tooltip';
+export class Tooltip<T = {}> extends Tooltip_<T> {}
+export { TooltipProps } from './lib/Tooltip';
+import {
+  UncontrolledAlert as UncontrolledAlert_,
+  UncontrolledButtonDropdown as UncontrolledButtonDropdown_,
+  UncontrolledDropdown as UncontrolledDropdown_,
+  UncontrolledTooltip as UncontrolledTooltip_,
+  UncontrolledCollapse as UncontrolledCollapse_,
+  UncontrolledCarousel as UncontrolledCarousel_,
+  UncontrolledPopover as UncontrolledPopover_
+} from './lib/Uncontrolled';
+export class UncontrolledAlert<T = {}> extends UncontrolledAlert_<T> {}
+export class UncontrolledButtonDropdown<T = {}> extends UncontrolledButtonDropdown_<T> {}
+export class UncontrolledDropdown<T = {}> extends UncontrolledDropdown_<T> {}
+export class UncontrolledTooltip<T = {}> extends UncontrolledTooltip_<T> {}
+export class UncontrolledCollapse<T = {}> extends UncontrolledCollapse_<T> {}
+export class UncontrolledCarousel<T = {}> extends UncontrolledCarousel_<T> {}
+export class UncontrolledPopover<T = {}> extends UncontrolledPopover_<T> {}
+export {
+  UncontrolledButtonDropdownProps,
+  UncontrolledAlertProps,
+  UncontrolledDropdownProps,
+  UncontrolledTooltipProps,
+  UncontrolledCollapseProps,
+  UncontrolledCarouselProps,
+  UncontrolledPopoverProps
+} from './lib/Uncontrolled';

types/reactstrap/v7/lib/Alert.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+import { FadeProps } from './Fade';
+
+export type UncontrolledProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  className?: string;
+  cssModule?: CSSModule;
+  color?: string;
+  tag?: React.ReactType;
+  transition?: FadeProps;
+} & T;
+export type UncontrolledAlertProps<T = {}> = UncontrolledProps<T>;
+
+export type AlertProps<T = {}> = UncontrolledAlertProps<T> & {
+  isOpen?: boolean;
+  toggle?: () => void;
+};
+
+declare class Alert<T = {[key: string]: any}> extends React.Component<AlertProps<T>> {}
+export default Alert;

types/reactstrap/v7/lib/Badge.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type BadgeProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  color?: string;
+  pill?: boolean;
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class Badge<T = {[key: string]: any}> extends React.Component<BadgeProps<T>> {}
+export default Badge;

types/reactstrap/v7/lib/Breadcrumb.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type BreadcrumbProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: string;
+  className?: string;
+  listTag?: string;
+  listClassName?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class Breadcrumb<T = {[key: string]: any}> extends React.Component<BreadcrumbProps<T>> {}
+export default Breadcrumb;

types/reactstrap/v7/lib/BreadcrumbItem.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type BreadcrumbItemProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  active?: boolean;
+  className?: string;
+  cssModule?: CSSModule;
+  // if a is passed as a string
+  // this could be href
+  [others: string]: any;
+} & T;
+
+declare class BreadcrumbItem<T = {[key: string]: any}> extends React.Component<BreadcrumbItemProps<T>> {}
+export default BreadcrumbItem;

types/reactstrap/v7/lib/Button.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type ButtonProps<T = {}> = React.ButtonHTMLAttributes<HTMLButtonElement> & {
+  outline?: boolean;
+  active?: boolean;
+  block?: boolean;
+  color?: string;
+  disabled?: boolean;
+  tag?: React.ReactType;
+  innerRef?: React.Ref<HTMLButtonElement>;
+
+  onClick?: React.MouseEventHandler<any>;
+  size?: any;
+  id?: string;
+  style?: React.CSSProperties;
+
+  cssModule?: CSSModule;
+} & T;
+
+declare class Button<T = {[key: string]: any}> extends React.Component<ButtonProps<T>> {}
+export default Button;

types/reactstrap/v7/lib/ButtonDropdown.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { UncontrolledDropdownProps, DropdownProps } from './Dropdown';
+
+export type UncontrolledProps<T = {}> = UncontrolledDropdownProps<T>;
+export type UncontrolledButtonDropdownProps<T = {}> = UncontrolledProps<T>;
+
+export type ButtonDropdownProps<T = {}> = DropdownProps<T>;
+
+declare class ButtonDropdown<T = {[key: string]: any}> extends React.Component<ButtonDropdownProps<T>> {}
+export default ButtonDropdown;

types/reactstrap/v7/lib/ButtonGroup.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type ButtonGroupProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  'aria-label'?: string;
+  className?: string;
+  cssModule?: CSSModule;
+  role?: string;
+  size?: string;
+  vertical?: boolean;
+} & T;
+
+declare class ButtonGroup<T = {[key: string]: any}> extends React.Component<ButtonGroupProps<T>> {}
+export default ButtonGroup;

types/reactstrap/v7/lib/ButtonToolbar.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type ButtonToolbarProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  'aria-label'?: string;
+  className?: string;
+  cssModule?: CSSModule;
+  role?: string;
+} & T;
+
+declare class ButtonToolbar<T = {[key: string]: any}> extends React.Component<ButtonToolbarProps<T>> {}
+export default ButtonToolbar;

types/reactstrap/v7/lib/Card.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type CardProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  inverse?: boolean;
+  color?: string;
+  block?: boolean;
+  body?: boolean;
+  outline?: boolean;
+  className?: string;
+  cssModule?: CSSModule;
+  style?: React.CSSProperties;
+} & T;
+
+declare class Card<T = {[key: string]: any}> extends React.Component<CardProps<T>> {}
+export default Card;

types/reactstrap/v7/lib/CardBody.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type CardBodyProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class CardBody<T = {[key: string]: any}> extends React.Component<CardBodyProps<T>> {}
+export default CardBody;

types/reactstrap/v7/lib/CardColumns.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type CardColumnsProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class CardColumns<T = {[key: string]: any}> extends React.Component<CardColumnsProps<T>> {}
+export default CardColumns;

types/reactstrap/v7/lib/CardDeck.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type CardDeckProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class CardDeck<T = {[key: string]: any}> extends React.Component<CardDeckProps<T>> {}
+export default CardDeck;

types/reactstrap/v7/lib/CardFooter.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type CardFooterProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class CardFooter<T = {[key: string]: any}> extends React.Component<CardFooterProps<T>> {}
+export default CardFooter;

types/reactstrap/v7/lib/CardGroup.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type CardGroupProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class CardGroup<T = {[key: string]: any}> extends React.Component<CardGroupProps<T>> {}
+export default CardGroup;

types/reactstrap/v7/lib/CardHeader.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type CardHeaderProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class CardHeader<T = {[key: string]: any}> extends React.Component<CardHeaderProps<T>> {}
+export default CardHeader;

types/reactstrap/v7/lib/CardImg.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type CardImgProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  top?: boolean;
+  bottom?: boolean;
+  className?: string;
+  cssModule?: CSSModule;
+  src?: string;
+  width?: string;
+  height?: string;
+  alt?: string;
+} & T;
+
+declare class CardImg<T = {[key: string]: any}> extends React.Component<CardImgProps<T>> {}
+export default CardImg;

types/reactstrap/v7/lib/CardImgOverlay.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type CardImgOverlayProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class CardImgOverlay<T = {[key: string]: any}> extends React.Component<CardImgOverlayProps<T>> {}
+export default CardImgOverlay;

types/reactstrap/v7/lib/CardLink.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type CardLinkProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  innerRef?: React.Ref<HTMLAnchorElement>;
+  className?: string;
+  cssModule?: CSSModule;
+  href?: string;
+} & T;
+
+declare class CardLink<T = {[key: string]: any}> extends React.Component<CardLinkProps<T>> {}
+export default CardLink;

types/reactstrap/v7/lib/CardSubtitle.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type CardSubtitleProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class CardSubtitle<T = {[key: string]: any}> extends React.Component<CardSubtitleProps<T>> {}
+export default CardSubtitle;

types/reactstrap/v7/lib/CardText.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type CardTextProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class CardText<T = {[key: string]: any}> extends React.Component<CardTextProps<T>> {}
+export default CardText;

types/reactstrap/v7/lib/CardTitle.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type CardTitleProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class CardTitle<T = {[key: string]: any}> extends React.Component<CardTitleProps<T>> {}
+export default CardTitle;

types/reactstrap/v7/lib/Carousel.d.ts

@@ -0,0 +1,39 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type CarouselProps<T = {}> = React.HTMLProps<HTMLElement> & {
+    activeIndex?: number;
+    next: () => void;
+    previous: () => void;
+    keyboard?: boolean;
+    pause?: 'hover' | false;
+    ride?: 'carousel';
+    interval?: number | string | boolean;
+    mouseEnter?: () => void;
+    mouseExit?: () => void;
+    slide?: boolean;
+    cssModule?: CSSModule
+} & T;
+
+export type UncontrolledProps<T = {}> = React.HTMLProps<HTMLElement> & {
+    items: any[];
+    activeIndex?: number;
+    next?: () => void;
+    previous?: () => void;
+    keyboard?: boolean;
+    pause?: "hover" | false;
+    ride?: "carousel";
+    interval?: number | string | boolean;
+    mouseEnter?: () => void;
+    mouseExit?: () => void;
+    slide?: boolean;
+    cssModule?: CSSModule;
+    controls?: boolean;
+    indicators?: boolean;
+    autoPlay?: boolean;
+} & T;
+
+export type UncontrolledCarouselProps<T = {}> = UncontrolledProps<T>;
+
+declare class Carousel<T = {[key: string]: any}> extends React.Component<CarouselProps<T>> {}
+export default Carousel;

types/reactstrap/v7/lib/CarouselCaption.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type CarouselCaptionProps<T = {}> = React.HTMLProps<HTMLElement> & {
+    captionHeader?: string;
+    captionText: string;
+    cssModule?: CSSModule;
+} & T;
+
+declare class CarouselCaption<T = {[key: string]: any}> extends React.Component<CarouselCaptionProps<T>> {}
+export default CarouselCaption;

types/reactstrap/v7/lib/CarouselControl.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type CarouselControlProps<T = {}> = React.HTMLProps<HTMLElement> & {
+    direction: 'prev' | 'next';
+    onClickHandler: () => void;
+    cssModule?: CSSModule;
+    directionText: string;
+} & T;
+
+declare class CarouselControl<T = {[key: string]: any}> extends React.Component<CarouselControlProps<T>> {}
+export default CarouselControl;

types/reactstrap/v7/lib/CarouselIndicators.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type CarouselIndicatorsProps<T = {}> = React.HTMLProps<HTMLElement> & {
+    items: object[];
+    activeIndex: number;
+    cssModule?: CSSModule;
+    onClickHandler: (idx: number) => void;
+} & T;
+
+declare class CarouselIndicators<T = {[key: string]: any}> extends React.Component<CarouselIndicatorsProps<T>> {}
+export default CarouselIndicators;

types/reactstrap/v7/lib/CarouselItem.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export interface Transition {
+    onEnter?: () => void;
+    onEntering?: () => void;
+    onEntered?: () => void;
+    onExit?: () => void;
+    onExiting?: () => void;
+    onExited?: () => void;
+}
+
+export type CarouselItemProps<T = {}> = React.HTMLProps<HTMLElement> & Transition & {
+    tag?: React.ReactType;
+    in?: boolean;
+    cssModule?: CSSModule;
+    slide?: boolean;
+} & T;
+
+declare class CarouselItem<T = {[key: string]: any}> extends React.Component<CarouselItemProps<T>> {}
+export default CarouselItem;

types/reactstrap/v7/lib/Col.d.ts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+
+export type ColumnProps
+  = string
+  | boolean
+  | number
+  | {
+    size?: boolean | number | string
+    push?: string | number
+    pull?: string | number
+    offset?: string | number
+    order?: string | number
+  };
+
+export type ColProps<T = {}> = React.HTMLProps<HTMLDivElement> & {
+  tag?: React.ReactType;
+  xs?: ColumnProps;
+  sm?: ColumnProps;
+  md?: ColumnProps;
+  lg?: ColumnProps;
+  xl?: ColumnProps;
+
+  // custom widths
+  widths?: string[];
+} & T;
+
+declare class Col<T = {[key: string]: any}> extends React.Component<ColProps<T>> {}
+export default Col;

types/reactstrap/v7/lib/Collapse.d.ts

@@ -0,0 +1,35 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type CollapseProps<T = {}> = React.HTMLProps<HTMLElement> & {
+  isOpen?: boolean;
+  classNames?: string;
+  cssModule?: CSSModule;
+  tag?: React.ReactType;
+  navbar?: boolean;
+  delay?: {
+    show: number
+    hide: number
+  };
+  onOpened?: () => void;
+  onClosed?: () => void;
+  onEntering?: () => void;
+  onEntered?: () => void;
+  onExit?: () => void;
+  onExiting?: () => void;
+  onExited?: () => void;
+} & T;
+
+export type UncontrolledProps<T = {}> = React.HTMLProps<HTMLElement> & {
+  isOpen?: boolean;
+  className?: string;
+  cssModule?: CSSModule;
+  tag?: React.ReactType;
+  navbar?: boolean;
+  toggle?: () => void;
+} & T;
+
+export type UncontrolledCollapseProps<T = {}> = UncontrolledProps<T>;
+
+declare class Collapse<T = {[key: string]: any}> extends React.Component<CollapseProps<T>> {}
+export default Collapse;

types/reactstrap/v7/lib/Container.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type ContainerProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  fluid?: boolean;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class Container<T = {[key: string]: any}> extends React.Component<ContainerProps<T>> {}
+export default Container;

types/reactstrap/v7/lib/CustomInput.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type CustomInputType =
+  | 'select'
+  | 'file'
+  | 'radio'
+  | 'checkbox'
+  | 'switch';
+
+export type CustomInputProps<T = {}> = React.InputHTMLAttributes<HTMLInputElement> & {
+  type: CustomInputType;
+  label?: React.ReactNode;
+  inline?: boolean;
+  bsSize?: 'lg' | 'sm';
+  valid?: boolean;
+  invalid?: boolean;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class CustomInput<T = {[key: string]: any}> extends React.Component<CustomInputProps<T>> {}
+export default CustomInput;

types/reactstrap/v7/lib/Dropdown.d.ts

@@ -0,0 +1,34 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type Direction =
+  | "up"
+  | "down"
+  | "left"
+  | "right";
+
+export type UncontrolledProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  isOpen?: boolean;
+  toggle?: () => void;
+  className?: string;
+  cssModule?: CSSModule;
+  nav?: boolean;
+  inNavbar?: boolean;
+  setActiveFromChild?: boolean;
+} & T;
+
+export type UncontrolledDropdownProps<T = {}> = UncontrolledProps<T>;
+
+export type Props<T = {}> = UncontrolledProps<T> & {
+  disabled?: boolean;
+  direction?: Direction;
+  group?: boolean;
+  size?: string;
+  tag?: React.ReactType;
+  addonType?: boolean | 'prepend' | 'append';
+};
+
+export type DropdownProps<T = {}> = Props<T>;
+
+declare class Dropdown<T = {[key: string]: any}> extends React.Component<DropdownProps<T>> {}
+export default Dropdown;

types/reactstrap/v7/lib/DropdownItem.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type DropdownItemProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  disabled?: boolean;
+  divider?: boolean;
+  tag?: React.ReactType;
+  header?: boolean;
+  onClick?: (event: React.MouseEvent<any>) => void;
+  className?: string;
+  cssModule?: CSSModule;
+  href?: string;
+  toggle?: boolean;
+  active?: boolean;
+} & T;
+
+declare class DropdownItem<T> extends React.Component<DropdownItemProps<T>> {}
+export default DropdownItem;

types/reactstrap/v7/lib/DropdownMenu.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import * as Popper from 'popper.js';
+import { CSSModule } from '../index';
+
+export type DropdownMenuProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  right?: boolean;
+  className?: string;
+  cssModule?: CSSModule;
+  flip?: boolean;
+  modifiers?: Popper.Modifiers;
+  persist?: boolean;
+} & T;
+
+declare class DropdownMenu<T = {[key: string]: any}> extends React.Component<DropdownMenuProps<T>> {}
+export default DropdownMenu;

types/reactstrap/v7/lib/DropdownToggle.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type DropdownToggleProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  caret?: boolean;
+  className?: string;
+  cssModule?: CSSModule;
+  disabled?: boolean;
+  onClick?: React.MouseEventHandler<any>;
+  outline?: boolean;
+  'data-toggle'?: string;
+  'aria-haspopup'?: boolean;
+  split?: boolean;
+  tag?: React.ReactType;
+  nav?: boolean;
+  color?: string;
+  size?: string;
+} & T;
+
+declare class DropdownToggle<T> extends React.Component<DropdownToggleProps<T>> {}
+export default DropdownToggle;

types/reactstrap/v7/lib/Fade.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type FadeProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  in?: boolean;
+  baseClass?: string;
+  baseClassIn?: string;
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+  transitionAppearTimeout?: number;
+  transitionEnterTimeout?: number;
+  transitionLeaveTimeout?: number;
+  transitionAppear?: boolean;
+  transitionEnter?: boolean;
+  transitionLeave?: boolean;
+  onLeave?: () => void;
+  onEnter?: () => void;
+} & T;
+
+declare class Fade<T = {[key: string]: any}> extends React.Component<FadeProps<T>> {}
+export default Fade;

types/reactstrap/v7/lib/Form.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type FormProps<T = {}> = React.HTMLProps<HTMLFormElement> & {
+  inline?: boolean;
+  tag?: React.ReactType;
+  innerRef?: React.Ref<HTMLFormElement>;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class Form<T> extends React.Component<FormProps<T>> {}
+export default Form;

types/reactstrap/v7/lib/FormFeedback.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type FormFeedbackProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: string;
+  className?: string;
+  cssModule?: CSSModule;
+  valid?: boolean;
+} & T;
+
+declare class FormFeedback<T = {[key: string]: any}> extends React.Component<FormFeedbackProps<T>> {}
+export default FormFeedback;

types/reactstrap/v7/lib/FormGroup.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type FormGroupProps<T = {}> = React.HTMLProps<HTMLDivElement> & {
+  row?: boolean;
+  check?: boolean;
+  inline?: boolean;
+  disabled?: boolean;
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class FormGroup<T = {[key: string]: any}> extends React.Component<FormGroupProps<T>> {}
+export default FormGroup;

types/reactstrap/v7/lib/FormText.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type FormTextProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  inline?: boolean;
+  tag?: React.ReactType;
+  color?: string;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class FormText<T = {[key: string]: any}> extends React.Component<FormTextProps<T>> {}
+export default FormText;

types/reactstrap/v7/lib/Input.d.ts

@@ -0,0 +1,46 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type InputType =
+  | 'text'
+  | 'email'
+  | 'select'
+  | 'file'
+  | 'radio'
+  | 'checkbox'
+  | 'textarea'
+  | 'button'
+  | 'reset'
+  | 'submit'
+  | 'date'
+  | 'datetime-local'
+  | 'hidden'
+  | 'image'
+  | 'month'
+  | 'number'
+  | 'range'
+  | 'search'
+  | 'tel'
+  | 'url'
+  | 'week'
+  | 'password'
+  | 'datetime'
+  | 'time'
+  | 'color';
+
+export type InputProps<T = {}> = React.InputHTMLAttributes<HTMLInputElement> & {
+  type?: InputType;
+  bsSize?: 'lg' | 'sm';
+  state?: string;
+  valid?: boolean;
+  invalid?: boolean;
+  tag?: React.ReactType;
+  innerRef?: React.Ref<HTMLInputElement>;
+  plaintext?: boolean;
+  addon?: boolean;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class Input<T> extends React.Component<InputProps<T>> {}
+export default Input;

types/reactstrap/v7/lib/InputGroup.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type InputGroupProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  size?: string;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class InputGroup<T = {[key: string]: any}> extends React.Component<InputGroupProps<T>> {}
+export default InputGroup;

types/reactstrap/v7/lib/InputGroupAddon.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type InputGroupAddonProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+  addonType: 'prepend' | 'append';
+} & T;
+
+declare class InputGroupAddon<T = {[key: string]: any}> extends React.Component<InputGroupAddonProps<T>> {}
+export default InputGroupAddon;

types/reactstrap/v7/lib/InputGroupButtonDropdown.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { DropdownProps } from './Dropdown';
+
+export type InputGroupButtonDropdownProps<T = {}> = DropdownProps & {
+    addonType: 'prepend' | 'append';
+} & T;
+
+declare class InputGroupButtonDropdown<T = {[key: string]: any}> extends React.Component<InputGroupButtonDropdownProps<T>> {}
+export default InputGroupButtonDropdown;

types/reactstrap/v7/lib/InputGroupText.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type InputGroupTextProps<T = {}> = React.HTMLAttributes<HTMLElement>  & {
+  tag?: React.ReactType;
+  cssModule?: CSSModule;
+} & T;
+
+declare class InputGroupText<T = {[key: string]: any}> extends React.Component<InputGroupTextProps<T>> {}
+export default InputGroupText;

types/reactstrap/v7/lib/Jumbotron.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type JumbotronProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  fluid?: boolean;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class Jumbotron<T = {[key: string]: any}> extends React.Component<JumbotronProps<T>> {}
+export default Jumbotron;

types/reactstrap/v7/lib/Label.d.ts

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+import { ColumnProps } from './Col';
+
+type Intermediate = React.LabelHTMLAttributes<HTMLLabelElement> & {
+  size?: any;
+};
+
+export type LabelProps<T = {}> = Intermediate & {
+  hidden?: boolean;
+  check?: boolean;
+  inline?: boolean;
+  disabled?: boolean;
+  size?: string;
+  for?: string;
+  tag?: string;
+  className?: string;
+  cssModule?: CSSModule;
+  xs?: ColumnProps;
+  sm?: ColumnProps;
+  md?: ColumnProps;
+  lg?: ColumnProps;
+  xl?: ColumnProps;
+} & T;
+
+declare class Label<T = {[key: string]: any}> extends React.Component<LabelProps<T>> {}
+export default Label;

types/reactstrap/v7/lib/ListGroup.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type ListGroupProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  flush?: boolean;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class ListGroup<T = {[key: string]: any}> extends React.Component<ListGroupProps<T>> {}
+export default ListGroup;

types/reactstrap/v7/lib/ListGroupItem.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type ListGroupItemProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  active?: boolean;
+  disabled?: boolean;
+  color?: string;
+  action?: boolean;
+  className?: string;
+  cssModule?: CSSModule;
+  href?: string;
+
+  onClick?: React.MouseEventHandler<any>;
+} & T;
+
+declare class ListGroupItem<T = {[key: string]: any}> extends React.Component<ListGroupItemProps<T>> {}
+export default ListGroupItem;

types/reactstrap/v7/lib/ListGroupItemHeading.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type ListGroupItemHeadingProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class ListGroupItemHeading<T = {[key: string]: any}> extends React.Component<ListGroupItemHeadingProps<T>> {}
+export default ListGroupItemHeading;

types/reactstrap/v7/lib/ListGroupItemText.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type ListGroupItemTextProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class ListGroupItemText<T = {[key: string]: any}> extends React.Component<ListGroupItemTextProps<T>> {}
+export default ListGroupItemText;

types/reactstrap/v7/lib/Media.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type MediaProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  body?: boolean;
+  bottom?: boolean;
+  className?: string;
+  cssModule?: CSSModule;
+  heading?: boolean;
+  left?: boolean;
+  list?: boolean;
+  middle?: boolean;
+  object?: boolean;
+  right?: boolean;
+  tag?: React.ReactType;
+  top?: boolean;
+  src?: string;
+  href?: string;
+  alt?: string;
+} & T;
+
+declare class Media<T = {[key: string]: any}> extends React.Component<MediaProps<T>> {}
+export default Media;

types/reactstrap/v7/lib/Modal.d.ts

@@ -0,0 +1,33 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+import { FadeProps } from './Fade';
+
+export type ModalProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  isOpen?: boolean;
+  autoFocus?: boolean;
+  size?: string;
+  toggle?: () => void;
+  keyboard?: boolean;
+  backdrop?: boolean | 'static';
+  onEnter?: () => void;
+  onExit?: () => void;
+  onOpened?: () => void;
+  onClosed?: () => void;
+  className?: string;
+  cssModule?: CSSModule;
+  wrapClassName?: string;
+  modalClassName?: string;
+  backdropClassName?: string;
+  contentClassName?: string;
+  zIndex?: number | string;
+  fade?: boolean;
+  backdropTransition?: FadeProps;
+  modalTransition?: FadeProps;
+  centered?: boolean;
+  external?: React.ReactNode;
+  labelledBy?: string;
+  role?: string;
+} & T;
+
+declare class Modal<T> extends React.Component<ModalProps<T>> {}
+export default Modal;

types/reactstrap/v7/lib/ModalBody.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type ModalBodyProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class ModalBody<T = {[key: string]: any}> extends React.Component<ModalBodyProps<T>> {}
+export default ModalBody;

types/reactstrap/v7/lib/ModalFooter.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type ModalFooterProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class ModalFooter<T = {[key: string]: any}> extends React.Component<ModalFooterProps<T>> {}
+export default ModalFooter;

types/reactstrap/v7/lib/ModalHeader.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type ModalHeaderProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+  wrapTag?: React.ReactType;
+  toggle?: () => void;
+} & T;
+
+declare class ModalHeader<T = {[key: string]: any}> extends React.Component<ModalHeaderProps<T>> {}
+export default ModalHeader;

types/reactstrap/v7/lib/Nav.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type NavProps<T = {}> = React.HTMLProps<HTMLUListElement> & {
+  tabs?: boolean;
+  pills?: boolean;
+  vertical?: boolean | string;
+  horizontal?: string;
+  justified?: boolean;
+  fill?: boolean;
+  navbar?: boolean;
+  card?: boolean;
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class Nav<T = {[key: string]: any}> extends React.Component<NavProps<T>> {}
+export default Nav;

types/reactstrap/v7/lib/NavItem.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type NavItemProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  active?: boolean;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class NavItem<T = {[key: string]: any}> extends React.Component<NavItemProps<T>> {}
+export default NavItem;

types/reactstrap/v7/lib/NavLink.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type NavLinkProps<T = {}> = React.HTMLProps<HTMLAnchorElement> & {
+  tag?: React.ReactType;
+  innerRef?: React.Ref<HTMLAnchorElement>;
+  disabled?: boolean;
+  active?: boolean;
+  className?: string;
+  cssModule?: CSSModule;
+  onClick?: React.MouseEventHandler<any>;
+  href?: string;
+} & T;
+
+declare class NavLink<T> extends React.Component<NavLinkProps<T>> {}
+export default NavLink;

types/reactstrap/v7/lib/Navbar.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type NavbarProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  light?: boolean;
+  dark?: boolean;
+  inverse?: boolean;
+  full?: boolean;
+  fixed?: string;
+  sticky?: string;
+  color?: string;
+  role?: string;
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+  toggleable?: boolean | string;
+  expand?: boolean | string;
+} & T;
+
+declare class Navbar<T = {[key: string]: any}> extends React.Component<NavbarProps<T>> {}
+export default Navbar;

types/reactstrap/v7/lib/NavbarBrand.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type NavbarBrandProps<T = {}> = React.HTMLProps<HTMLAnchorElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class NavbarBrand<T = {[key: string]: any}> extends React.Component<NavbarBrandProps<T>> {}
+export default NavbarBrand;

types/reactstrap/v7/lib/NavbarToggler.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type NavbarTogglerProps<T = {}> = React.HTMLProps<HTMLAnchorElement> & {
+  tag?: React.ReactType;
+  type?: string;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class NavbarToggler<T = {[key: string]: any}> extends React.Component<NavbarTogglerProps<T>> {}
+export default NavbarToggler;

types/reactstrap/v7/lib/Pagination.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type PaginationProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  className?: string;
+  cssModule?: CSSModule;
+  size?: string;
+} & T;
+
+declare class Pagination<T = {[key: string]: any}> extends React.Component<PaginationProps<T>> {}
+export default Pagination;

types/reactstrap/v7/lib/PaginationItem.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type PaginationItemProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  className?: string;
+  cssModule?: CSSModule;
+  active?: boolean;
+  disabled?: boolean;
+  tag?: React.ReactType;
+} & T;
+
+declare class PaginationItem<T = {[key: string]: any}> extends React.Component<PaginationItemProps<T>> {}
+export default PaginationItem;

types/reactstrap/v7/lib/PaginationLink.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type PaginationLinkProps<T = {}> = React.HTMLProps<HTMLAnchorElement> & {
+  'aria-label'?: string;
+  className?: string;
+  cssModule?: CSSModule;
+  next?: boolean;
+  previous?: boolean;
+  tag?: React.ReactType;
+} & T;
+
+declare class PaginationLink<T = {[key: string]: any}> extends React.Component<PaginationLinkProps<T>> {}
+export default PaginationLink;

types/reactstrap/v7/lib/Popover.d.ts

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import * as Popper from 'popper.js';
+import { CSSModule } from '../index';
+
+export type PopoverProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  isOpen?: boolean;
+  toggle?: () => void;
+  target: string | HTMLElement;
+  container?: string | HTMLElement;
+  boundariesElement?: Popper.Boundary | Element;
+  className?: string;
+  placement?: Popper.Placement;
+  innerClassName?: string;
+  disabled?: boolean;
+  hideArrow?: boolean;
+  placementPrefix?: string;
+  delay?: number | {show: number, hide: number};
+  modifiers?: Popper.Modifiers;
+  cssModule?: CSSModule;
+} & T;
+
+export type UncontrolledPopoverProps<T = {}> = PopoverProps<T> & {
+    defaultOpen?: boolean;
+};
+
+declare class Popover<T> extends React.Component<PopoverProps<T>> {}
+export default Popover;

types/reactstrap/v7/lib/PopoverBody.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type PopoverBodyProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class PopoverBody<T = {[key: string]: any}> extends React.Component<PopoverBodyProps<T>> {}
+export default PopoverBody;

types/reactstrap/v7/lib/PopoverHeader.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type PopoverHeaderProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class PopoverHeader<T = {[key: string]: any}> extends React.Component<PopoverHeaderProps<T>> {}
+export default PopoverHeader;

types/reactstrap/v7/lib/Progress.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type ProgressProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  bar?: boolean;
+  multi?: boolean;
+  tag?: string;
+  value?: string | number;
+  max?: string | number;
+  animated?: boolean;
+  striped?: boolean;
+  color?: string;
+  className?: string;
+  cssModule?: CSSModule;
+  barClassName?: string;
+} & T;
+
+declare class Progress<T = {[key: string]: any}> extends React.Component<ProgressProps<T>> {}
+export default Progress;

types/reactstrap/v7/lib/Row.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type RowProps<T = {}> = React.HTMLProps<HTMLElement> & {
+  className?: string;
+  cssModule?: CSSModule;
+  tag?: React.ReactType;
+  noGutters?: boolean;
+} & T;
+
+declare class Row<T = {[key: string]: any}> extends React.Component<RowProps<T>> {}
+export default Row;

types/reactstrap/v7/lib/Spinner.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type SpinnerProps<T = {}> = React.HTMLProps<HTMLElement> & {
+  tag?: React.ReactType;
+  type?: string;
+  size?: any;
+  color?: string;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class Spinner<T = {[key: string]: any}> extends React.Component<SpinnerProps<T>> {}
+export default Spinner;

types/reactstrap/v7/lib/TabContent.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type TabContentProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  activeTab?: number | string;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class TabContent<T> extends React.Component<TabContentProps<T>> {}
+export default TabContent;

types/reactstrap/v7/lib/TabPane.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type TabPaneProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+  tabId?: number | string;
+} & T;
+
+declare class TabPane<T = {[key: string]: any}> extends React.Component<TabPaneProps<T>> {}
+export default TabPane;

types/reactstrap/v7/lib/Table.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type TableProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  className?: string;
+  cssModule?: CSSModule;
+  size?: string;
+  bordered?: boolean;
+  borderless?: boolean;
+  striped?: boolean;
+  inverse?: boolean;
+  hover?: boolean;
+  reflow?: boolean;
+  responsive?: boolean;
+  tag?: React.ReactType;
+  responsiveTag?: React.ReactType;
+} & T;
+
+declare class Table<T = {[key: string]: any}> extends React.Component<TableProps<T>> {}
+export default Table;

types/reactstrap/v7/lib/Tag.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { CSSModule } from '../index';
+
+export type TagProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  color?: string;
+  pill?: boolean;
+  tag?: React.ReactType;
+  className?: string;
+  cssModule?: CSSModule;
+} & T;
+
+declare class Tag<T = {[key: string]: any}> extends React.Component<TagProps<T>> {}
+export default Tag;

types/reactstrap/v7/lib/Tooltip.d.ts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import * as Popper from 'popper.js';
+import { CSSModule } from '../index';
+
+export type UncontrolledProps<T = {}> = React.HTMLAttributes<HTMLElement> & {
+  target: string | HTMLElement;
+  container?: string | HTMLElement;
+  delay?: number | {show: number, hide: number};
+  className?: string;
+  innerClassName?: string;
+  autohide?: boolean;
+  placement?: Popper.Placement;
+  modifiers?: Popper.Modifiers;
+  cssModule?: CSSModule;
+} & T;
+export type UncontrolledTooltipProps<T = {}> = UncontrolledProps<T>;
+
+export type TooltipProps<T = {}> = UncontrolledTooltipProps<T> & {
+  toggle?: () => void;
+  isOpen?: boolean;
+};
+
+declare class Tooltip<T> extends React.Component<TooltipProps<T>> {}
+export default Tooltip;

types/reactstrap/v7/lib/Uncontrolled.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+
+import { UncontrolledAlertProps          } from './Alert';
+import { UncontrolledButtonDropdownProps } from './ButtonDropdown';
+import { UncontrolledDropdownProps       } from './Dropdown';
+import { UncontrolledTooltipProps        } from './Tooltip';
+import { UncontrolledCollapseProps       } from './Collapse';
+import { UncontrolledCarouselProps       } from './Carousel';
+import { UncontrolledPopoverProps        } from './Popover';
+
+export class UncontrolledAlert<T = {}> extends React.Component<UncontrolledAlertProps<T>> {}
+export class UncontrolledButtonDropdown<T = {}> extends React.Component<UncontrolledButtonDropdownProps<T>> {}
+export class UncontrolledDropdown<T = {}> extends React.Component<UncontrolledDropdownProps<T>> {}
+export class UncontrolledTooltip<T = {}> extends React.Component<UncontrolledTooltipProps<T>> {}
+export class UncontrolledCollapse<T = {}> extends React.Component<UncontrolledCollapseProps<T>> {}
+export class UncontrolledCarousel<T = {}> extends React.Component<UncontrolledCarouselProps<T>> {}
+export class UncontrolledPopover<T = {}> extends React.Component<UncontrolledPopoverProps<T>> {}
+
+export { UncontrolledAlertProps          } from './Alert';
+export { UncontrolledButtonDropdownProps } from './ButtonDropdown';
+export { UncontrolledDropdownProps       } from './Dropdown';
+export { UncontrolledTooltipProps        } from './Tooltip';
+export { UncontrolledCollapseProps       } from './Collapse';
+export { UncontrolledCarouselProps       } from './Carousel';
+export { UncontrolledPopoverProps        } from './Popover';

types/reactstrap/v7/tsconfig.json

@@ -0,0 +1,25 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6",
+            "dom"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "jsx": "react",
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "reactstrap-tests.tsx"
+    ]
+}

types/reactstrap/v7/tslint.json

@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }