Expose components props, fix imports

types/react-bootstrap/index.d.ts

@@ -8,11 +8,15 @@
 //                 Cheng Sieu Ly <https://github.com/chengsieuly>,
 //                 Kat Busch <https://github.com/katbusch>,
 //                 Vito Samson <https://github.com/vitosamson>
+//                 Karol Janyst <https://github.com/LKay>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.3
 
 import * as React from 'react';
 
+export type Diff<T extends string, U extends string> = ({ [P in T]: P } & { [P in U]: never } & { [x: string]: never })[T];
+export type Omit<T, K extends keyof T> = Pick<T, Diff<keyof T, K>>;
+
 export type Sizes = 'xs' | 'xsmall' | 'sm' | 'small' | 'medium' | 'lg' | 'large';
 
 export interface SelectCallback extends React.EventHandler<any> {
@@ -34,92 +38,4 @@ export interface TransitionCallbacks {
   onExiting?(node: HTMLElement): any;
 }
 
-export {
-  Accordion,
-  Alert,
-  Badge,
-  Breadcrumb,
-  BreadcrumbItem,
-  Button,
-  ButtonGroup,
-  ButtonToolbar,
-  Carousel,
-  CarouselCaption,
-  CarouselItem,
-  Checkbox,
-  Clearfix,
-  Col,
-  Collapse,
-  ControlLabel,
-  Dropdown,
-  DropdownButton,
-  DropdownMenu,
-  DropdownToggle,
-  Fade,
-  Form,
-  FormControl,
-  FormControlFeedback,
-  FormControlStatic,
-  FormGroup,
-  Glyphicon,
-  Grid,
-  HelpBlock,
-  Image,
-  InputGroup,
-  InputGroupAddon,
-  InputGroupButton,
-  Jumbotron,
-  Label,
-  ListGroup,
-  ListGroupItem,
-  Media,
-  MediaBody,
-  MediaHeading,
-  MediaLeft,
-  MediaList,
-  MediaListItem,
-  MediaRight,
-  MenuItem,
-  Modal,
-  ModalBody,
-  ModalDialog,
-  ModalFooter,
-  ModalHeader,
-  ModalTitle,
-  Nav,
-  Navbar,
-  NavbarBrand,
-  NavbarCollapse,
-  NavbarHeader,
-  NavbarToggle,
-  NavDropdown,
-  NavItem,
-  Overlay,
-  OverlayTrigger,
-  PageHeader,
-  PageItem,
-  Pager,
-  PagerItem,
-  Pagination,
-  PaginationButton,
-  Panel,
-  PanelGroup,
-  Popover,
-  ProgressBar,
-  Radio,
-  ResponsiveEmbed,
-  Row,
-  SafeAnchor,
-  SplitButton,
-  SplitToggle,
-  Tab,
-  TabContainer,
-  TabContent,
-  Table,
-  TabPane,
-  Tabs,
-  Thumbnail,
-  Tooltip,
-  Well,
-  utils,
-} from './lib';
+export * from './lib';

types/react-bootstrap/lib/Accordion.d.ts

@@ -1,17 +1,19 @@
 import * as React from 'react';
 import { Sizes } from 'react-bootstrap';
 
-declare class Accordion extends React.Component<AccordionProps> { }
-declare namespace Accordion { }
+declare namespace Accordion {
+    export interface AccordionProps extends React.HTMLProps<Accordion> {
+        bsSize?: Sizes;
+        bsStyle?: string;
+        collapsible?: boolean;
+        defaultExpanded?: boolean;
+        eventKey?: any;
+        expanded?: boolean;
+        footer?: React.ReactNode;
+        header?: React.ReactNode;
+    }
+}
+declare class Accordion extends React.Component<Accordion.AccordionProps> { }
 export = Accordion;
 
-interface AccordionProps extends React.HTMLProps<Accordion> {
-  bsSize?: Sizes;
-  bsStyle?: string;
-  collapsible?: boolean;
-  defaultExpanded?: boolean;
-  eventKey?: any;
-  expanded?: boolean;
-  footer?: any; // TODO: Add more specific type
-  header?: any; // TODO: Add more specific type
-}
+

types/react-bootstrap/lib/Alert.d.ts

@@ -1,14 +1,15 @@
 import * as React from 'react';
 import { Sizes } from 'react-bootstrap';
 
-declare class Alert extends React.Component<AlertProps> { }
-declare namespace Alert { }
-export = Alert
-
-interface AlertProps extends React.HTMLProps<Alert> {
-  bsSize?: Sizes;
-  bsStyle?: string;
-  closeLabel?: string;
-  /** @deprecated since v0.29.0 */ dismissAfter?: number;
-  onDismiss?: Function;
+declare namespace Alert {
+    export interface AlertProps extends React.HTMLProps<Alert> {
+        bsSize?: Sizes;
+        bsStyle?: string;
+        closeLabel?: string;
+        /** @deprecated since v0.29.0 */dismissAfter?: number;
+        // TODO: Add more specific type
+        onDismiss?: Function;
+    }
 }
+declare class Alert extends React.Component<Alert.AlertProps> { }
+export = Alert;

types/react-bootstrap/lib/Badge.d.ts

@@ -1,10 +1,10 @@
 import * as React from 'react';
 
-declare class Badge extends React.Component<BadgeProps> { }
-declare namespace Badge { }
-export = Badge
-
-interface BadgeProps extends React.HTMLProps<Badge> {
-  bsClass?: string;
-  pullRight?: boolean;
+declare namespace Badge {
+    export interface BadgeProps extends React.HTMLProps<Badge> {
+        bsClass?: string;
+        pullRight?: boolean;
+    }
 }
+declare class Badge extends React.Component<Badge.BadgeProps> { }
+export = Badge;

types/react-bootstrap/lib/Breadcrumb.d.ts

@@ -1,12 +1,12 @@
 import * as React from 'react';
 import * as BreadcrumbItem from './BreadcrumbItem';
 
-declare class Breadcrumb extends React.Component<BreadcrumbProps> {
-  public static Item: typeof BreadcrumbItem;
+declare namespace Breadcrumb {
+    interface BreadcrumbProps extends React.HTMLProps<Breadcrumb> {
+        bsClass?: string;
+    }
 }
-declare namespace Breadcrumb { }
-export = Breadcrumb
-
-interface BreadcrumbProps extends React.HTMLProps<Breadcrumb> {
-  bsClass?: string;
+declare class Breadcrumb extends React.Component<Breadcrumb.BreadcrumbProps> {
+    public static Item: typeof BreadcrumbItem;
 }
+export = Breadcrumb;

types/react-bootstrap/lib/BreadcrumbItem.d.ts

@@ -1,12 +1,12 @@
 import * as React from 'react';
 
-declare class BreadcrumbItem extends React.Component<BreadcrumbItemProps> { }
-declare namespace BreadcrumbItem { }
-export = BreadcrumbItem
-
-interface BreadcrumbItemProps extends React.Props<BreadcrumbItem> {
-  active?: boolean;
-  href?: string;
-  title?: React.ReactNode;
-  target?: string;
+declare namespace BreadcrumbItem {
+    export interface BreadcrumbItemProps extends React.Props<BreadcrumbItem> {
+        active?: boolean;
+        href?: string;
+        title?: React.ReactNode;
+        target?: string;
+    }
 }
+declare class BreadcrumbItem extends React.Component<BreadcrumbItem.BreadcrumbItemProps> { }
+export = BreadcrumbItem;

types/react-bootstrap/lib/Button.d.ts

@@ -1,16 +1,16 @@
 import * as React from 'react';
 import { Sizes } from 'react-bootstrap';
 
-declare class Button extends React.Component<ButtonProps> { }
-declare namespace Button { }
-export = Button
-
-interface ButtonProps extends React.HTMLProps<Button> {
-  bsClass?: string;
-  active?: boolean;
-  block?: boolean;
-  bsStyle?: string;
-  bsSize?: Sizes;
-  componentClass?: React.ReactType;
-  disabled?: boolean;
+declare namespace Button {
+    export interface ButtonProps extends React.HTMLProps<Button> {
+        bsClass?: string;
+        active?: boolean;
+        block?: boolean;
+        bsStyle?: string;
+        bsSize?: Sizes;
+        componentClass?: React.ReactType;
+        disabled?: boolean;
+    }
 }
+declare class Button extends React.Component<Button.ButtonProps> { }
+export = Button;

types/react-bootstrap/lib/ButtonGroup.d.ts

@@ -1,14 +1,14 @@
 import * as React from 'react';
 import { Sizes } from 'react-bootstrap';
 
-declare class ButtonGroup extends React.Component<ButtonGroupProps> { }
-declare namespace ButtonGroup { }
-export = ButtonGroup
-
-interface ButtonGroupProps extends React.HTMLProps<ButtonGroup> {
-  block?: boolean;
-  bsSize?: Sizes;
-  bsStyle?: string;
-  justified?: boolean;
-  vertical?: boolean;
+declare namespace ButtonGroup {
+    export interface ButtonGroupProps extends React.HTMLProps<ButtonGroup> {
+        block?: boolean;
+        bsSize?: Sizes;
+        bsStyle?: string;
+        justified?: boolean;
+        vertical?: boolean;
+    }
 }
+declare class ButtonGroup extends React.Component<ButtonGroup.ButtonGroupProps> { }
+export = ButtonGroup;

types/react-bootstrap/lib/ButtonToolbar.d.ts

@@ -1,14 +1,14 @@
 import * as React from 'react';
 import { Sizes } from 'react-bootstrap';
 
-declare class ButtonToolbar extends React.Component<ButtonToolbarProps> { }
-declare namespace ButtonToolbar { }
-export = ButtonToolbar
-
-interface ButtonToolbarProps extends React.HTMLProps<ButtonToolbar> {
-  block?: boolean;
-  bsSize?: Sizes;
-  bsStyle?: string;
-  justified?: boolean;
-  vertical?: boolean;
+declare namespace ButtonToolbar {
+    export interface ButtonToolbarProps extends React.HTMLProps<ButtonToolbar> {
+        block?: boolean;
+        bsSize?: Sizes;
+        bsStyle?: string;
+        justified?: boolean;
+        vertical?: boolean;
+    }
 }
+declare class ButtonToolbar extends React.Component<ButtonToolbar.ButtonToolbarProps> { }
+export = ButtonToolbar;

types/react-bootstrap/lib/Carousel.d.ts

@@ -1,31 +1,30 @@
 import * as React from 'react';
-import { Sizes, SelectCallback } from 'react-bootstrap';
+import { Omit, Sizes, SelectCallback } from 'react-bootstrap';
 import * as CarouselItem from './CarouselItem';
 import * as CarouselCaption from './CarouselCaption';
 
-declare class Carousel extends React.Component<CarouselProps> {
-  public static Caption: typeof CarouselCaption;
-  public static Item: typeof CarouselItem;
+declare namespace Carousel {
+    export interface CarouselProps extends Omit<React.HTMLProps<Carousel>, 'wrap'> {
+        activeIndex?: number;
+        bsSize?: Sizes;
+        bsStyle?: string;
+        controls?: boolean;
+        defaultActiveIndex?: number;
+        direction?: string;
+        indicators?: boolean;
+        interval?: number;
+        nextIcon?: React.ReactNode;
+        onSelect?: SelectCallback;
+        // TODO: Add more specific type
+        onSlideEnd?: Function;
+        pauseOnHover?: boolean;
+        prevIcon?: React.ReactNode;
+        slide?: boolean;
+        wrap?: boolean;
+    }
 }
-declare namespace Carousel { }
-export = Carousel
-
-interface CarouselProps extends React.HTMLProps<Carousel> {
-  activeIndex?: number;
-  bsSize?: Sizes;
-  bsStyle?: string;
-  controls?: boolean;
-  defaultActiveIndex?: number;
-  direction?: string;
-  indicators?: boolean;
-  interval?: number;
-  nextIcon?: React.ReactNode;
-  onSelect?: SelectCallback;
-  onSlideEnd?: Function;
-  pauseOnHover?: boolean;
-  prevIcon?: React.ReactNode;
-  slide?: boolean;
-
-  // TODO: this is incompatible with HTMLProps.wrap, which is a string
-  // wrap?: boolean;
+declare class Carousel extends React.Component<Carousel.CarouselProps> {
+    public static Caption: typeof CarouselCaption;
+    public static Item: typeof CarouselItem;
 }
+export = Carousel;

types/react-bootstrap/lib/CarouselCaption.d.ts

@@ -1,9 +1,9 @@
 import * as React from 'react';
 
-declare class CarouselCaption extends React.Component<CarouselCaptionProps> { }
-declare namespace CarouselCaption { }
-export = CarouselCaption
-
-interface CarouselCaptionProps extends React.HTMLProps<CarouselCaption> {
-  componentClass?: React.ReactType;
+declare namespace CarouselCaption {
+    export interface CarouselCaptionProps extends React.HTMLProps<CarouselCaption> {
+        componentClass?: React.ReactType;
+    }
 }
+declare class CarouselCaption extends React.Component<CarouselCaption.CarouselCaptionProps> { }
+export = CarouselCaption;

types/react-bootstrap/lib/CarouselItem.d.ts

@@ -1,14 +1,15 @@
 import * as React from 'react';
 
-declare class CarouselItem extends React.Component<CarouselItemProps> { }
-declare namespace CarouselItem { }
-export = CarouselItem
-
-interface CarouselItemProps extends React.HTMLProps<CarouselItem> {
-  active?: boolean;
-  animtateIn?: boolean;
-  animateOut?: boolean;
-  direction?: string;
-  index?: number;
-  onAnimateOutEnd?: Function;
+declare namespace CarouselItem {
+    interface CarouselItemProps extends React.HTMLProps<CarouselItem> {
+        active?: boolean;
+        animtateIn?: boolean;
+        animateOut?: boolean;
+        direction?: string;
+        index?: number;
+        // TODO: Add more specific type
+        onAnimateOutEnd?: Function;
+    }
 }
+declare class CarouselItem extends React.Component<CarouselItem.CarouselItemProps> { }
+export = CarouselItem;

types/react-bootstrap/lib/Checkbox.d.ts

@@ -1,13 +1,13 @@
 import * as React from 'react';
 
-declare class Checkbox extends React.Component<CheckboxProps> { }
-declare namespace Checkbox { }
-export = Checkbox
-
-interface CheckboxProps extends React.HTMLProps<Checkbox> {
-  bsClass?: string;
-  disabled?: boolean;
-  inline?: boolean;
-  inputRef?: (instance: HTMLInputElement) => void;
-  validationState?: "success" | "warning" | "error";
+declare namespace Checkbox {
+    export interface CheckboxProps extends React.HTMLProps<Checkbox> {
+        bsClass?: string;
+        disabled?: boolean;
+        inline?: boolean;
+        inputRef?: (instance: HTMLInputElement) => void;
+        validationState?: "success" | "warning" | "error";
+    }
 }
+declare class Checkbox extends React.Component<Checkbox.CheckboxProps> { }
+export = Checkbox;

types/react-bootstrap/lib/Clearfix.d.ts

@@ -1,13 +1,13 @@
 import * as React from 'react';
 
-declare class Clearfix extends React.Component<ClearfixProps> { }
-declare namespace Clearfix { }
-export = Clearfix
-
-interface ClearfixProps extends React.HTMLProps<Clearfix> {
-  componentClass?: React.ReactType,
-  visibleXsBlock?: boolean;
-  visibleSmBlock?: boolean;
-  visibleMdBlock?: boolean;
-  visibleLgBlock?: boolean;
+declare namespace Clearfix {
+    export interface ClearfixProps extends React.HTMLProps<Clearfix> {
+        componentClass?: React.ReactType,
+        visibleXsBlock?: boolean;
+        visibleSmBlock?: boolean;
+        visibleMdBlock?: boolean;
+        visibleLgBlock?: boolean;
+    }
 }
+declare class Clearfix extends React.Component<Clearfix.ClearfixProps> { }
+export = Clearfix;

types/react-bootstrap/lib/Col.d.ts

@@ -1,29 +1,29 @@
 import * as React from 'react';
 
-declare class Col extends React.Component<ColProps> { }
-declare namespace Col { }
-export = Col
-
-interface ColProps extends React.HTMLProps<Col> {
-  componentClass?: React.ReactType;
-  lg?: number;
-  lgHidden?: boolean;
-  lgOffset?: number;
-  lgPull?: number;
-  lgPush?: number;
-  md?: number;
-  mdHidden?: boolean;
-  mdOffset?: number;
-  mdPull?: number;
-  mdPush?: number;
-  sm?: number;
-  smHidden?: boolean;
-  smOffset?: number;
-  smPull?: number;
-  smPush?: number;
-  xs?: number;
-  xsHidden?: boolean;
-  xsOffset?: number;
-  xsPull?: number;
-  xsPush?: number;
+declare namespace Col {
+    export interface ColProps extends React.HTMLProps<Col> {
+        componentClass?: React.ReactType;
+        lg?: number;
+        lgHidden?: boolean;
+        lgOffset?: number;
+        lgPull?: number;
+        lgPush?: number;
+        md?: number;
+        mdHidden?: boolean;
+        mdOffset?: number;
+        mdPull?: number;
+        mdPush?: number;
+        sm?: number;
+        smHidden?: boolean;
+        smOffset?: number;
+        smPull?: number;
+        smPush?: number;
+        xs?: number;
+        xsHidden?: boolean;
+        xsOffset?: number;
+        xsPull?: number;
+        xsPush?: number;
+    }
 }
+declare class Col extends React.Component<Col.ColProps> { }
+export = Col;

types/react-bootstrap/lib/Collapse.d.ts

@@ -1,15 +1,15 @@
 import * as React from 'react';
 import { TransitionCallbacks } from 'react-bootstrap';
 
-declare class Collapse extends React.Component<CollapseProps> { }
-declare namespace Collapse { }
-export = Collapse
-
-interface CollapseProps extends TransitionCallbacks, React.Props<Collapse> {
-  dimension?: 'height' | 'width' | { ( ):string };
-  getDimensionValue?: ( dimension:number, element:React.ReactElement<any> ) => number;
-  in?: boolean;
-  timeout?: number;
-  transitionAppear?: boolean;
-  unmountOnExit?: boolean;
+declare namespace Collapse {
+    export interface CollapseProps extends TransitionCallbacks, React.ClassAttributes<Collapse> {
+        dimension?: 'height' | 'width' | { ( ):string };
+        getDimensionValue?: ( dimension:number, element:React.ReactElement<any> ) => number;
+        in?: boolean;
+        timeout?: number;
+        transitionAppear?: boolean;
+        unmountOnExit?: boolean;
+    }
 }
+declare class Collapse extends React.Component<Collapse.CollapseProps> { }
+export = Collapse;

types/react-bootstrap/lib/ControlLabel.d.ts

@@ -1,11 +1,11 @@
 import * as React from 'react';
 
-declare class ControlLabel extends React.Component<ControlLabelProps> { }
-declare namespace ControlLabel { }
-export = ControlLabel
-
-interface ControlLabelProps extends React.HTMLProps<ControlLabel> {
-  bsClass?: string;
-  htmlFor?: string;
-  srOnly?: boolean;
+declare namespace ControlLabel {
+    export interface ControlLabelProps extends React.HTMLProps<ControlLabel> {
+        bsClass?: string;
+        htmlFor?: string;
+        srOnly?: boolean;
+    }
 }
+declare class ControlLabel extends React.Component<ControlLabel.ControlLabelProps> { }
+export = ControlLabel;

types/react-bootstrap/lib/Dropdown.d.ts

@@ -3,26 +3,28 @@ import { SelectCallback } from 'react-bootstrap';
 import * as DropdownToggle from './DropdownToggle';
 import * as DropdownMenu from './DropdownMenu';
 
-declare class Dropdown extends React.Component<DropdownProps> {
+declare namespace Dropdown {
+    export interface DropdownBaseProps {
+        bsClass?: string;
+        componentClass?: React.ReactType;
+        disabled?: boolean;
+        dropup?: boolean;
+        id: string;
+        onClose?: Function;
+        onSelect?: SelectCallback;
+        onToggle?: (isOpen: boolean) => void;
+        open?: boolean;
+        pullRight?: boolean;
+        role?: string;
+    }
+
+    export type DropdownProps = Dropdown.DropdownBaseProps & React.HTMLProps<Dropdown>;
+}
+
+declare class Dropdown extends React.Component<Dropdown.DropdownProps> {
   public static Menu: typeof DropdownMenu;
   public static Toggle: typeof DropdownToggle;
 }
-export = Dropdown
+export = Dropdown;
 
-type DropdownProps = Dropdown.DropdownBaseProps & React.HTMLProps<Dropdown>;
 
-declare namespace Dropdown {
-  interface DropdownBaseProps {
-    bsClass?: string;
-    componentClass?: React.ReactType;
-    disabled?: boolean;
-    dropup?: boolean;
-    id: string;
-    onClose?: Function;
-    onSelect?: SelectCallback;
-    onToggle?: (isOpen: boolean) => void;
-    open?: boolean;
-    pullRight?: boolean;
-    role?: string;
-  }
-}

types/react-bootstrap/lib/DropdownButton.d.ts

@@ -2,17 +2,18 @@ import * as React from 'react';
 import { Sizes } from 'react-bootstrap';
 import { DropdownBaseProps } from './Dropdown';
 
-declare class DropdownButton extends React.Component<DropdownButtonProps> { }
-declare namespace DropdownButton { }
-export = DropdownButton
+declare namespace DropdownButton {
+    export interface DropdownButtonBaseProps extends DropdownBaseProps {
+        block?: boolean;
+        bsSize?: Sizes;
+        bsStyle?: string;
+        navItem?: boolean;
+        noCaret?: boolean;
+        pullRight?: boolean;
+    }
+
+    export type DropdownButtonProps = DropdownButtonBaseProps & React.HTMLProps<DropdownButton>;
 
-interface DropdownButtonBaseProps extends DropdownBaseProps {
-  block?: boolean;
-  bsSize?: Sizes;
-  bsStyle?: string;
-  navItem?: boolean;
-  noCaret?: boolean;
-  pullRight?: boolean;
 }
-
-type DropdownButtonProps = DropdownButtonBaseProps & React.HTMLProps<DropdownButton>;
+declare class DropdownButton extends React.Component<DropdownButton.DropdownButtonProps> { }
+export = DropdownButton;

types/react-bootstrap/lib/DropdownMenu.d.ts

@@ -1,14 +1,14 @@
 import * as React from 'react';
 import { SelectCallback } from 'react-bootstrap';
 
-declare class DropdownMenu extends React.Component<DropdownMenuProps> { }
-declare namespace DropdownMenu { }
-export = DropdownMenu
-
-interface DropdownMenuProps extends React.HTMLProps<DropdownMenu> {
-  labelledBy?: string | number;
-  onClose?: Function;
-  onSelect?: SelectCallback;
-  open?: boolean;
-  pullRight?: boolean;
+declare namespace DropdownMenu {
+    export interface DropdownMenuProps extends React.HTMLProps<DropdownMenu> {
+        labelledBy?: string | number;
+        onClose?: Function;
+        onSelect?: SelectCallback;
+        open?: boolean;
+        pullRight?: boolean;
+    }
 }
+declare class DropdownMenu extends React.Component<DropdownMenu.DropdownMenuProps> { }
+export = DropdownMenu;

types/react-bootstrap/lib/DropdownToggle.d.ts

@@ -1,16 +1,15 @@
 import * as React from 'react';
 
-declare class DropdownToggle extends React.Component<DropdownToggle.DropdownToggleProps> { }
-export = DropdownToggle
-
 declare namespace DropdownToggle {
-  interface DropdownToggleProps extends React.HTMLProps<DropdownToggle> {
-    bsRole?: string;
-    noCaret?: boolean;
-    open?: boolean;
-    title?: string;
-    useAnchor?: boolean;
-    bsClass?:string; // Added since v0.30.0
-    bsStyle?:string;
-  }
+    export interface DropdownToggleProps extends React.HTMLProps<DropdownToggle> {
+        bsRole?: string;
+        noCaret?: boolean;
+        open?: boolean;
+        title?: string;
+        useAnchor?: boolean;
+        bsClass?:string; // Added since v0.30.0
+        bsStyle?:string;
+    }
 }
+declare class DropdownToggle extends React.Component<DropdownToggle.DropdownToggleProps> { }
+export = DropdownToggle;

types/react-bootstrap/lib/Fade.d.ts

@@ -1,13 +1,13 @@
 import * as React from 'react';
 import { TransitionCallbacks } from 'react-bootstrap';
 
-declare class Fade extends React.Component<FadeProps> { }
-declare namespace Fade { }
-export = Fade
-
-interface FadeProps extends TransitionCallbacks, React.HTMLProps<Fade> {
-  in?: boolean;
-  timeout?: number;
-  transitionAppear?: boolean;
-  unmountOnExit?: boolean;
+declare namespace Fade {
+    export interface FadeProps extends TransitionCallbacks, React.HTMLProps<Fade> {
+        in?: boolean;
+        timeout?: number;
+        transitionAppear?: boolean;
+        unmountOnExit?: boolean;
+    }
 }
+declare class Fade extends React.Component<Fade.FadeProps> { }
+export = Fade;

types/react-bootstrap/lib/Form.d.ts

@@ -1,12 +1,12 @@
 import * as React from 'react';
 
-declare class Form extends React.Component<FormProps> { }
-declare namespace Form { }
-export = Form
-
-interface FormProps extends React.HTMLProps<Form> {
-  bsClass?: string;
-  componentClass?: React.ReactType;
-  horizontal?: boolean;
-  inline?: boolean;
+declare namespace Form {
+    export interface FormProps extends React.HTMLProps<Form> {
+        bsClass?: string;
+        componentClass?: React.ReactType;
+        horizontal?: boolean;
+        inline?: boolean;
+    }
 }
+declare class Form extends React.Component<Form.FormProps> { }
+export = Form;

types/react-bootstrap/lib/FormControl.d.ts

@@ -3,18 +3,18 @@ import { Sizes } from 'react-bootstrap';
 import * as FormControlFeedback from './FormControlFeedback';
 import * as FormControlStatic from './FormControlStatic';
 
-declare class FormControl extends React.Component<FormControlProps> {
-  public static Feedback: typeof FormControlFeedback;
-  public static Static: typeof FormControlStatic;
+declare namespace FormControl {
+    export interface FormControlProps extends React.HTMLProps<FormControl> {
+        bsClass?: string;
+        bsSize?: Sizes;
+        componentClass?: React.ReactType;
+        id?: string;
+        inputRef?: (instance: HTMLInputElement) => void;
+        type?: string;
+    }
 }
-declare namespace FormControl { }
-export = FormControl
-
-interface FormControlProps extends React.HTMLProps<FormControl> {
-  bsClass?: string;
-  bsSize?: Sizes;
-  componentClass?: React.ReactType;
-  id?: string;
-  inputRef?: (instance: HTMLInputElement) => void;
-  type?: string;
+declare class FormControl extends React.Component<FormControl.FormControlProps> {
+    public static Feedback: typeof FormControlFeedback;
+    public static Static: typeof FormControlStatic;
 }
+export = FormControl;

types/react-bootstrap/lib/FormControlFeedback.d.ts

@@ -1,7 +1,7 @@
 import * as React from 'react';
 
-declare class FormControlFeedback extends React.Component<FormControlFeedbackProps> { }
-declare namespace FormControlFeedback { }
-export = FormControlFeedback
-
-interface FormControlFeedbackProps extends React.HTMLProps<FormControlFeedback> { }
+declare namespace FormControlFeedback {
+    export type FormControlFeedbackProps = React.HTMLProps<FormControlFeedback>;
+}
+declare class FormControlFeedback extends React.Component<FormControlFeedback.FormControlFeedbackProps> { }
+export = FormControlFeedback;

types/react-bootstrap/lib/FormControlStatic.d.ts

@@ -1,10 +1,10 @@
 import * as React from 'react';
 
-declare class FormControlStatic extends React.Component<FormControlStaticProps> { }
-declare namespace FormControlStatic { }
-export = FormControlStatic
-
-interface FormControlStaticProps extends React.HTMLProps<FormControlStatic> {
-  bsClass?: string;
-  componentClass?: React.ReactType;
+declare namespace FormControlStatic {
+    export interface FormControlStaticProps extends React.HTMLProps<FormControlStatic> {
+        bsClass?: string;
+        componentClass?: React.ReactType;
+    }
 }
+declare class FormControlStatic extends React.Component<FormControlStatic.FormControlStaticProps> { }
+export = FormControlStatic

types/react-bootstrap/lib/FormGroup.d.ts

@@ -1,13 +1,13 @@
 import * as React from 'react';
 import { Sizes } from 'react-bootstrap';
 
-declare class FormGroup extends React.Component<FormGroupProps> { }
-declare namespace FormGroup { }
-export = FormGroup
-
-interface FormGroupProps extends React.HTMLProps<FormGroup> {
-  bsClass?: string;
-  bsSize?: Sizes;
-  controlId?: string;
-  validationState?: "success" | "warning" | "error";
+declare namespace FormGroup {
+    export interface FormGroupProps extends React.HTMLProps<FormGroup> {
+        bsClass?: string;
+        bsSize?: Sizes;
+        controlId?: string;
+        validationState?: "success" | "warning" | "error";
+    }
 }
+declare class FormGroup extends React.Component<FormGroup.FormGroupProps> { }
+export = FormGroup;

types/react-bootstrap/lib/Glyphicon.d.ts

@@ -1,10 +1,10 @@
 import * as React from 'react';
 
-declare class Glyphicon extends React.Component<GlyphiconProps> { }
-declare namespace Glyphicon { }
-export = Glyphicon
-
-interface GlyphiconProps extends React.HTMLProps<Glyphicon> {
-  // Required
-  glyph: string;
+declare namespace Glyphicon {
+    export interface GlyphiconProps extends React.HTMLProps<Glyphicon> {
+        // Required
+        glyph: string;
+    }
 }
+declare class Glyphicon extends React.Component<Glyphicon.GlyphiconProps> { }
+export = Glyphicon;

types/react-bootstrap/lib/Grid.d.ts

@@ -1,11 +1,11 @@
 import * as React from 'react';
 
-declare class Grid extends React.Component<GridProps> { }
-declare namespace Grid { }
-export = Grid
-
-interface GridProps extends React.HTMLProps<Grid> {
-  componentClass?: React.ReactType;
-  fluid?: boolean;
-  bsClass?: string;
+declare namespace Grid {
+    export interface GridProps extends React.HTMLProps<Grid> {
+        componentClass?: React.ReactType;
+        fluid?: boolean;
+        bsClass?: string;
+    }
 }
+declare class Grid extends React.Component<Grid.GridProps> { }
+export = Grid;

types/react-bootstrap/lib/HelpBlock.d.ts

@@ -1,9 +1,9 @@
 import * as React from 'react';
 
-declare class HelpBlock extends React.Component<HelpBlockProps> { }
-declare namespace HelpBlock { }
-export = HelpBlock
-
-interface HelpBlockProps extends React.HTMLProps<HelpBlock> {
-  bsClass?: string;
+declare namespace HelpBlock {
+    export interface HelpBlockProps extends React.HTMLProps<HelpBlock> {
+        bsClass?: string;
+    }
 }
+declare class HelpBlock extends React.Component<HelpBlock.HelpBlockProps> { }
+export = HelpBlock;

types/react-bootstrap/lib/Image.d.ts

@@ -1,12 +1,12 @@
 import * as React from 'react';
 
-declare class Image extends React.Component<ImageProps> { }
-declare namespace Image { }
-export = Image
-
-interface ImageProps extends React.HTMLProps<Image> {
-  circle?: boolean;
-  responsive?: boolean;
-  rounded?: boolean;
-  thumbnail?: boolean;
+declare namespace Image {
+    export interface ImageProps extends React.HTMLProps<Image> {
+        circle?: boolean;
+        responsive?: boolean;
+        rounded?: boolean;
+        thumbnail?: boolean;
+    }
 }
+declare class Image extends React.Component<Image.ImageProps> { }
+export = Image;

types/react-bootstrap/lib/InputGroup.d.ts

@@ -3,14 +3,14 @@ import { Sizes } from 'react-bootstrap';
 import * as InputGroupAddon from './InputGroupAddon';
 import * as InputGroupButton from './InputGroupButton';
 
-declare class InputGroup extends React.Component<InputGroupProps> {
-  public static Addon: typeof InputGroupAddon;
-  public static Button: typeof InputGroupButton;
+declare namespace InputGroup {
+    export interface InputGroupProps extends React.HTMLProps<InputGroup> {
+        bsClass?: string;
+        bsSize?: Sizes;
+    }
 }
-declare namespace InputGroup { }
-export = InputGroup
-
-interface InputGroupProps extends React.HTMLProps<InputGroup> {
-  bsClass?: string;
-  bsSize?: Sizes;
+declare class InputGroup extends React.Component<InputGroup.InputGroupProps> {
+    public static Addon: typeof InputGroupAddon;
+    public static Button: typeof InputGroupButton;
 }
+export = InputGroup;

types/react-bootstrap/lib/InputGroupAddon.d.ts

@@ -1,7 +1,7 @@
 import * as React from 'react';
 
-declare class InputGroupAddon extends React.Component<InputGroupAddonProps> { }
-declare namespace InputGroupAddon { }
-export = InputGroupAddon
-
-interface InputGroupAddonProps extends React.HTMLProps<InputGroupAddon> { }
+declare namespace InputGroupAddon {
+    type InputGroupAddonProps = React.HTMLProps<InputGroupAddon>;
+}
+declare class InputGroupAddon extends React.Component<InputGroupAddon.InputGroupAddonProps> { }
+export = InputGroupAddon;

types/react-bootstrap/lib/InputGroupButton.d.ts

@@ -1,7 +1,7 @@
 import * as React from 'react';
 
-declare class InputGroupButton extends React.Component<InputGroupButtonProps> { }
-declare namespace InputGroupButton { }
-export = InputGroupButton
-
-interface InputGroupButtonProps extends React.HTMLProps<InputGroupButton> { }
+declare namespace InputGroupButton {
+    export type InputGroupButtonProps = React.HTMLProps<InputGroupButton>;
+}
+declare class InputGroupButton extends React.Component<InputGroupButton.InputGroupButtonProps> { }
+export = InputGroupButton;

types/react-bootstrap/lib/Jumbotron.d.ts

@@ -1,9 +1,9 @@
 import * as React from 'react';
 
-declare class Jumbotron extends React.Component<JumbotronProps> { }
-declare namespace Jumbotron { }
-export = Jumbotron
-
-interface JumbotronProps extends React.HTMLProps<Jumbotron> {
-  componentClass?: React.ReactType;
+declare namespace Jumbotron {
+    export interface JumbotronProps extends React.HTMLProps<Jumbotron> {
+        componentClass?: React.ReactType;
+    }
 }
+declare class Jumbotron extends React.Component<Jumbotron.JumbotronProps> { }
+export = Jumbotron;

types/react-bootstrap/lib/Label.d.ts

@@ -1,11 +1,11 @@
 import * as React from 'react';
 import { Sizes } from 'react-bootstrap';
 
-declare class Label extends React.Component<LabelProps> { }
-declare namespace Label { }
-export = Label
-
-interface LabelProps extends React.HTMLProps<Label> {
-  bsSize?: Sizes;
-  bsStyle?: string;
+declare namespace Label {
+    export interface LabelProps extends React.HTMLProps<Label> {
+        bsSize?: Sizes;
+        bsStyle?: string;
+    }
 }
+declare class Label extends React.Component<Label.LabelProps> { }
+export = Label;

types/react-bootstrap/lib/ListGroup.d.ts

@@ -1,10 +1,12 @@
 import * as React from 'react';
 
-declare class ListGroup extends React.Component<ListGroupProps> { }
-declare namespace ListGroup { }
-export = ListGroup
-
-interface ListGroupProps extends React.HTMLProps<ListGroup> {
-  componentClass?: React.ReactType; // Added since v0.30.0
-  fill?: boolean; // TODO: Add more specific type
+declare namespace ListGroup {
+    interface ListGroupProps extends React.HTMLProps<ListGroup> {
+        bsClass?: string;
+        componentClass?: React.ReactType; // Added since v0.30.0
+        // TODO: Add more specific type
+        fill?: boolean;
+    }
 }
+declare class ListGroup extends React.Component<ListGroup.ListGroupProps> { }
+export = ListGroup;

types/react-bootstrap/lib/ListGroupItem.d.ts

@@ -1,15 +1,15 @@
 import * as React from 'react';
 import { Sizes } from 'react-bootstrap';
 
-declare class ListGroupItem extends React.Component<ListGroupItemProps> { }
-declare namespace ListGroupItem { }
-export = ListGroupItem
-
-interface ListGroupItemProps extends React.HTMLProps<ListGroupItem> {
-  active?: any;
-  bsSize?: Sizes;
-  bsStyle?: string;
-  eventKey?: any;
-  header?: any; // TODO: Add more specific type
-  listItem?: boolean;
+declare namespace ListGroupItem {
+    export interface ListGroupItemProps extends React.HTMLProps<ListGroupItem> {
+        active?: any;
+        bsSize?: Sizes;
+        bsStyle?: string;
+        eventKey?: any;
+        header?: React.ReactNode;
+        listItem?: boolean;
+    }
 }
+declare class ListGroupItem extends React.Component<ListGroupItem.ListGroupItemProps> { }
+export = ListGroupItem;

types/react-bootstrap/lib/Media.d.ts

@@ -6,17 +6,17 @@ import * as MediaList from './MediaList';
 import * as MediaListItem from './MediaListItem';
 import * as MediaRight from './MediaRight';
 
-declare class Media extends React.Component<MediaProps> {
-  public static Body: typeof MediaBody;
-  public static Heading: typeof MediaHeading;
-  public static Left: typeof MediaLeft;
-  public static Right: typeof MediaRight;
-  public static List: typeof MediaList;
-  public static ListItem: typeof MediaListItem;
+declare namespace Media {
+    export interface MediaProps extends React.HTMLProps<Media> {
+        componentClass?: React.ReactType;
+    }
 }
-declare namespace Media { }
-export = Media
-
-interface MediaProps extends React.HTMLProps<Media> {
-  componentClass?: React.ReactType;
+declare class Media extends React.Component<Media.MediaProps> {
+    static Body: typeof MediaBody;
+    static Heading: typeof MediaHeading;
+    static Left: typeof MediaLeft;
+    static Right: typeof MediaRight;
+    static List: typeof MediaList;
+    static ListItem: typeof MediaListItem;
 }
+export = Media;

types/react-bootstrap/lib/MediaBody.d.ts

@@ -1,9 +1,9 @@
 import * as React from 'react';
 
-declare class MediaBody extends React.Component<MediaBodyProps> { }
-declare namespace MediaBody { }
-export = MediaBody
-
-interface MediaBodyProps extends React.Props<MediaBody> {
-  componentClass?: React.ReactType;
+declare namespace MediaBody {
+    export interface MediaBodyProps extends React.ClassAttributes<MediaBody> {
+        componentClass?: React.ReactType;
+    }
 }
+declare class MediaBody extends React.Component<MediaBody.MediaBodyProps> { }
+export = MediaBody;

types/react-bootstrap/lib/MediaHeading.d.ts

@@ -1,9 +1,9 @@
 import * as React from 'react';
 
-declare class MediaHeading extends React.Component<MediaHeadingProps> { }
-declare namespace MediaHeading { }
-export = MediaHeading
-
-interface MediaHeadingProps extends React.HTMLProps<MediaHeading> {
-  componentClass?: React.ReactType;
+declare namespace MediaHeading {
+    interface MediaHeadingProps extends React.HTMLProps<MediaHeading> {
+        componentClass?: React.ReactType;
+    }
 }
+declare class MediaHeading extends React.Component<MediaHeading.MediaHeadingProps> { }
+export = MediaHeading;

types/react-bootstrap/lib/MediaLeft.d.ts

@@ -1,9 +1,9 @@
 import * as React from 'react';
 
-declare class MediaLeft extends React.Component<MediaLeftProps> { }
-declare namespace MediaLeft { }
-export = MediaLeft
-
-interface MediaLeftProps extends React.HTMLProps<MediaLeft> {
-  align?: string;
+declare namespace MediaLeft {
+    export interface MediaLeftProps extends React.HTMLProps<MediaLeft> {
+        align?: string;
+    }
 }
+declare class MediaLeft extends React.Component<MediaLeft.MediaLeftProps> { }
+export = MediaLeft;

types/react-bootstrap/lib/MediaList.d.ts

@@ -1,7 +1,7 @@
 import * as React from 'react';
 
-declare class MediaList extends React.Component<MediaListProps> { }
-declare namespace MediaList { }
-export = MediaList
-
-interface MediaListProps extends React.HTMLProps<MediaList> { }
+declare namespace MediaList {
+    export type MediaListProps = React.HTMLProps<MediaList>;
+}
+declare class MediaList extends React.Component<MediaList.MediaListProps> { }
+export = MediaList;

types/react-bootstrap/lib/MediaListItem.d.ts

@@ -1,9 +1,9 @@
 import * as React from 'react';
 
-declare class MediaListItem extends React.Component<MediaListItemProps> { }
-declare namespace MediaListItem { }
-export = MediaListItem
-
-interface MediaListItemProps extends React.HTMLProps<MediaListItem> {
-  componentClass?: React.ReactType;
+declare namespace MediaListItem {
+    interface MediaListItemProps extends React.HTMLProps<MediaListItem> {
+        componentClass?: React.ReactType;
+    }
 }
+declare class MediaListItem extends React.Component<MediaListItem.MediaListItemProps> { }
+export = MediaListItem;

types/react-bootstrap/lib/MediaRight.d.ts

@@ -1,9 +1,9 @@
 import * as React from 'react';
 
-declare class MediaRight extends React.Component<MediaRightProps> { }
-declare namespace MediaRight { }
-export = MediaRight
-
-interface MediaRightProps extends React.HTMLProps<MediaRight> {
-  align?: string;
+declare namespace MediaRight {
+    export interface MediaRightProps extends React.HTMLProps<MediaRight> {
+        align?: string;
+    }
 }
+declare class MediaRight extends React.Component<MediaRight.MediaRightProps> { }
+export = MediaRight;

types/react-bootstrap/lib/MenuItem.d.ts

@@ -1,19 +1,19 @@
 import * as React from 'react';
 import { SelectCallback } from 'react-bootstrap';
 
-declare class MenuItem extends React.Component<MenuItemProps> { }
-declare namespace MenuItem { }
-export = MenuItem
-
-interface MenuItemProps extends React.HTMLProps<MenuItem> {
-  active?: boolean;
-  bsClass?: string;
-  disabled?: boolean;
-  divider?: boolean;
-  eventKey?: any;
-  header?: boolean;
-  onClick?: React.MouseEventHandler<{}>;
-  onSelect?: SelectCallback;
-  target?: string;
-  title?: string;
+declare namespace MenuItem {
+    export interface MenuItemProps extends React.HTMLProps<MenuItem> {
+        active?: boolean;
+        bsClass?: string;
+        disabled?: boolean;
+        divider?: boolean;
+        eventKey?: any;
+        header?: boolean;
+        onClick?: React.MouseEventHandler<{}>;
+        onSelect?: SelectCallback;
+        target?: string;
+        title?: string;
+    }
 }
+declare class MenuItem extends React.Component<MenuItem.MenuItemProps> { }
+export = MenuItem;

types/react-bootstrap/lib/Modal.d.ts

@@ -6,38 +6,38 @@ import * as ModalTitle from './ModalTitle';
 import * as ModalDialog from './ModalDialog';
 import * as ModalFooter from './ModalFooter';
 
-declare class Modal extends React.Component<ModalProps> {
-  public static Body: typeof ModalBody;
-  public static Header: typeof ModalHeader;
-  public static Title: typeof ModalTitle;
-  public static Footer: typeof ModalFooter;
-  public static Dialog: typeof ModalDialog;
-}
-declare namespace Modal { }
-export = Modal
+declare namespace Modal {
+    interface ModalProps extends TransitionCallbacks, React.HTMLProps<Modal> {
+        // Required
+        onHide: Function;
 
-interface ModalProps extends TransitionCallbacks, React.HTMLProps<Modal> {
-  // Required
-  onHide: Function;
-
-  // Optional
-  animation?: boolean;
-  autoFocus?: boolean;
-  backdrop?: boolean | string;
-  backdropClassName?: string;
-  backdropStyle?: any;
-  backdropTransitionTimeout?: number;
-  bsSize?: Sizes;
-  container?: any; // TODO: Add more specific type
-  containerClassName?: string;
-  dialogClassName?: string;
-  dialogComponent?: any; // TODO: Add more specific type
-  dialogTransitionTimeout?: number;
-  enforceFocus?: boolean;
-  keyboard?: boolean;
-  onBackdropClick?: (node: HTMLElement) => any;
-  onEscapeKeyUp?: (node: HTMLElement) => any;
-  onShow?: (node: HTMLElement) => any;
-  show?: boolean;
-  transition?: React.ReactElement<any>;
+        // Optional
+        animation?: boolean;
+        autoFocus?: boolean;
+        backdrop?: boolean | string;
+        backdropClassName?: string;
+        backdropStyle?: any;
+        backdropTransitionTimeout?: number;
+        bsSize?: Sizes;
+        container?: any; // TODO: Add more specific type
+        containerClassName?: string;
+        dialogClassName?: string;
+        dialogComponent?: any; // TODO: Add more specific type
+        dialogTransitionTimeout?: number;
+        enforceFocus?: boolean;
+        keyboard?: boolean;
+        onBackdropClick?: (node: HTMLElement) => any;
+        onEscapeKeyUp?: (node: HTMLElement) => any;
+        onShow?: (node: HTMLElement) => any;
+        show?: boolean;
+        transition?: React.ReactElement<any>;
+    }
 }
+declare class Modal extends React.Component<Modal.ModalProps> {
+    static Body: typeof ModalBody;
+    static Header: typeof ModalHeader;
+    static Title: typeof ModalTitle;
+    static Footer: typeof ModalFooter;
+    static Dialog: typeof ModalDialog;
+}
+export = Modal;

types/react-bootstrap/lib/ModalBody.d.ts

@@ -1,10 +1,9 @@
 import * as React from 'react';
 
-declare class ModalBody extends React.Component<ModalBodyProps> { }
-declare namespace ModalBody { }
-export = ModalBody
-
-interface ModalBodyProps extends React.HTMLProps<ModalBody> {
-  // TODO: these props are not correct https://github.com/react-bootstrap/react-bootstrap/blob/v0.31.1/src/ModalBody.js
-  modalClassName?: string;
+declare namespace ModalBody {
+    export interface ModalBodyProps extends React.HTMLProps<ModalBody> {
+        componentClass?: React.ReactType;
+    }
 }
+declare class ModalBody extends React.Component<ModalBody.ModalBodyProps> { }
+export = ModalBody;

types/react-bootstrap/lib/ModalDialog.d.ts

@@ -1,16 +1,16 @@
 import * as React from 'react';
 
-declare class ModalDialog extends React.Component<ModalDialogProps> { }
-declare namespace ModalDialog { }
-export = ModalDialog
-
-interface ModalDialogProps extends React.HTMLProps<ModalDialog> {
-  // TODO: these props are not correct https://github.com/react-bootstrap/react-bootstrap/blob/v0.31.1/src/ModalDialog.js#L9
-  onHide?: Function;
-  onEnter?: Function;
-  onEntered?: Function;
-  onEntering?: Function;
-  onExit?: Function;
-  onExited?: Function;
-  onExiting?: Function;
+declare namespace ModalDialog {
+    export interface ModalDialogProps extends React.HTMLProps<ModalDialog> {
+        // TODO: these props are not correct https://github.com/react-bootstrap/react-bootstrap/blob/v0.31.1/src/ModalDialog.js#L9
+        onHide?: Function;
+        onEnter?: Function;
+        onEntered?: Function;
+        onEntering?: Function;
+        onExit?: Function;
+        onExited?: Function;
+        onExiting?: Function;
+    }
 }
+declare class ModalDialog extends React.Component<ModalDialog.ModalDialogProps> { }
+export = ModalDialog;

types/react-bootstrap/lib/ModalFooter.d.ts

@@ -1,10 +1,9 @@
 import * as React from 'react';
 
-declare class ModalFooter extends React.Component<ModalFooterProps> { }
-declare namespace ModalFooter { }
-export = ModalFooter
-
-interface ModalFooterProps extends React.HTMLProps<ModalFooter> {
-  // TODO: these props are not correct https://github.com/react-bootstrap/react-bootstrap/blob/v0.31.1/src/ModalFooter.js
-  modalClassName?: string;
+declare namespace ModalFooter {
+    export interface ModalFooterProps extends React.HTMLProps<ModalFooter> {
+        componentClass?: React.ReactType;
+    }
 }
+declare class ModalFooter extends React.Component<ModalFooter.ModalFooterProps> { }
+export = ModalFooter;

types/react-bootstrap/lib/ModalHeader.d.ts

@@ -1,12 +1,11 @@
 import * as React from 'react';
 
-declare class ModalHeader extends React.Component<ModalHeaderProps> { }
-declare namespace ModalHeader { }
-export = ModalHeader
-
-interface ModalHeaderProps extends React.HTMLProps<ModalHeader> {
-  // TODO: these props are not correct https://github.com/react-bootstrap/react-bootstrap/blob/v0.31.1/src/ModalHeader.js
-  closeButton?: boolean;
-  modalClassName?: string;
-  onHide?: Function;
+declare namespace ModalHeader {
+    export interface ModalHeaderProps extends React.HTMLProps<ModalHeader> {
+        closeButton?: boolean;
+        closeLabel?: string;
+        onHide?: Function;
+    }
 }
+declare class ModalHeader extends React.Component<ModalHeader.ModalHeaderProps> { }
+export = ModalHeader;

types/react-bootstrap/lib/ModalTitle.d.ts

@@ -1,10 +1,9 @@
 import * as React from 'react';
 
-declare class ModalTitle extends React.Component<ModalTitleProps> { }
-declare namespace ModalTitle { }
-export = ModalTitle
-
-interface ModalTitleProps extends React.HTMLProps<ModalTitle> {
-  // TODO: props are not correct https://github.com/react-bootstrap/react-bootstrap/blob/v0.31.1/src/ModalTitle.js
-  modalClassName?: string;
+declare namespace ModalTitle {
+    export interface ModalTitleProps extends React.HTMLProps<ModalTitle> {
+        componentClass?: React.ReactType;
+    }
 }
+declare class ModalTitle extends React.Component<ModalTitle.ModalTitleProps> { }
+export = ModalTitle;

types/react-bootstrap/lib/Nav.d.ts

@@ -1,25 +1,24 @@
 import * as React from 'react';
 import { Sizes } from 'react-bootstrap';
 
-declare class Nav extends React.Component<NavProps> { }
-declare namespace Nav { }
-export = Nav
-
-// TODO: This one turned into a union of two different types
-interface NavProps extends React.HTMLProps<Nav> {
-  // Optional
-  activeHref?: string;
-  activeKey?: any;
-  bsSize?: Sizes;
-  bsStyle?: string;
-  collapsible?: boolean;
-  eventKey?: any;
-  expanded?: boolean;
-  justified?: boolean;
-  navbar?: boolean;
-  pullRight?: boolean;
-  right?: boolean;
-  stacked?: boolean;
-  ulClassName?: string;
-  ulId?: string;
+declare namespace Nav {
+    export interface NavProps extends React.HTMLProps<Nav> {
+        // Optional
+        activeHref?: string;
+        activeKey?: any;
+        bsSize?: Sizes;
+        bsStyle?: string;
+        collapsible?: boolean;
+        eventKey?: any;
+        expanded?: boolean;
+        justified?: boolean;
+        navbar?: boolean;
+        pullRight?: boolean;
+        right?: boolean;
+        stacked?: boolean;
+        ulClassName?: string;
+        ulId?: string;
+    }
 }
+declare class Nav extends React.Component<Nav.NavProps> { }
+export = Nav;

types/react-bootstrap/lib/NavDropdown.d.ts

@@ -1,14 +1,14 @@
 import * as React from 'react';
 import { DropdownBaseProps } from './Dropdown';
 
-declare class NavDropdown extends React.Component<NavDropdownProps> { }
-declare namespace NavDropdown { }
-export = NavDropdown
+declare namespace NavDropdown {
+    export interface NavDropdownBaseProps extends DropdownBaseProps {
+        active?: boolean;
+        noCaret?: boolean;
+        eventKey?: any;
+    }
 
-interface NavDropdownBaseProps extends DropdownBaseProps {
-  active?: boolean;
-  noCaret?: boolean;
-  eventKey?: any;
+    export type NavDropdownProps = NavDropdownBaseProps & React.HTMLProps<NavDropdown>;
 }
-
-type NavDropdownProps = NavDropdownBaseProps & React.HTMLProps<NavDropdown>;
+declare class NavDropdown extends React.Component<NavDropdown.NavDropdownProps> { }
+export = NavDropdown;

types/react-bootstrap/lib/NavItem.d.ts

@@ -1,27 +1,27 @@
 import * as React from 'react';
 import { Sizes, SelectCallback } from 'react-bootstrap';
 
-declare class NavItem extends React.Component<NavItemProps> { }
-declare namespace NavItem { }
-export = NavItem
-
-interface NavItemProps extends React.HTMLProps<NavItem> {
-  active?: boolean;
-  brand?: any; // TODO: Add more specific type
-  bsSize?: Sizes;
-  bsStyle?: string;
-  componentClass?: React.ReactType;
-  defaultNavExpanded?: boolean;
-  eventKey?: any;
-  fixedBottom?: boolean;
-  fixedTop?: boolean;
-  fluid?: boolean;
-  inverse?: boolean;
-  linkId?: string;
-  navExpanded?: boolean;
-  onSelect?: SelectCallback;
-  onToggle?: Function;
-  staticTop?: boolean;
-  toggleButton?: any; // TODO: Add more specific type
-  toggleNavKey?: string | number;
+declare namespace NavItem {
+    export interface NavItemProps extends React.HTMLProps<NavItem> {
+        active?: boolean;
+        brand?: any; // TODO: Add more specific type
+        bsSize?: Sizes;
+        bsStyle?: string;
+        componentClass?: React.ReactType;
+        defaultNavExpanded?: boolean;
+        eventKey?: any;
+        fixedBottom?: boolean;
+        fixedTop?: boolean;
+        fluid?: boolean;
+        inverse?: boolean;
+        linkId?: string;
+        navExpanded?: boolean;
+        onSelect?: SelectCallback;
+        onToggle?: Function;
+        staticTop?: boolean;
+        toggleButton?: any; // TODO: Add more specific type
+        toggleNavKey?: string | number;
+    }
 }
+declare class NavItem extends React.Component<NavItem.NavItemProps> { }
+export = NavItem;

types/react-bootstrap/lib/Navbar.d.ts

@@ -5,43 +5,43 @@ import * as NavbarCollapse from './NavbarCollapse';
 import * as NavbarHeader from './NavbarHeader';
 import * as NavbarToggle from './NavbarToggle';
 
-declare class Navbar extends React.Component<NavbarProps> {
-  public static Brand: typeof NavbarBrand;
-  public static Collapse: typeof NavbarCollapse;
-  public static Header: typeof NavbarHeader;
-  public static Toggle: typeof NavbarToggle;
-  public static Link: typeof NavbarLink;
-  public static Text: typeof NavbarText;
-  public static Form: typeof NavbarForm;
+declare namespace Navbar {
+    export interface NavbarProps extends React.HTMLProps<Navbar> {
+        brand?: any; // TODO: Add more specific type
+        bsSize?: Sizes;
+        bsStyle?: string;
+        collapseOnSelect?: boolean;
+        componentClass?: React.ReactType;
+        defaultNavExpanded?: boolean;
+        fixedBottom?: boolean;
+        fixedTop?: boolean;
+        fluid?: boolean;
+        inverse?: boolean;
+        navExpanded?: boolean;
+        onToggle?: Function;
+        staticTop?: boolean;
+        toggleButton?: any; // TODO: Add more specific type
+        toggleNavKey?: string | number;
+    }
 }
-declare namespace Navbar { }
-export = Navbar
-
-interface NavbarProps extends React.HTMLProps<Navbar> {
-  brand?: any; // TODO: Add more specific type
-  bsSize?: Sizes;
-  bsStyle?: string;
-  collapseOnSelect?: boolean;
-  componentClass?: React.ReactType;
-  defaultNavExpanded?: boolean;
-  fixedBottom?: boolean;
-  fixedTop?: boolean;
-  fluid?: boolean;
-  inverse?: boolean;
-  navExpanded?: boolean;
-  onToggle?: Function;
-  staticTop?: boolean;
-  toggleButton?: any; // TODO: Add more specific type
-  toggleNavKey?: string | number;
+declare class Navbar extends React.Component<Navbar.NavbarProps> {
+    static Brand: typeof NavbarBrand;
+    static Collapse: typeof NavbarCollapse;
+    static Header: typeof NavbarHeader;
+    static Toggle: typeof NavbarToggle;
+    static Link: typeof NavbarLink;
+    static Text: typeof NavbarText;
+    static Form: typeof NavbarForm;
 }
+export = Navbar;
 
 /**
  * the classes below aren't present in lib/
  */
 
-interface NavbarLinkProps extends React.Props<NavbarLink> {
+interface NavbarLinkProps extends React.HTMLProps<NavbarLink> {
   href: string;
-  onClick?: React.MouseEventHandler<HTMLAnchorElement>;
+  onClick?: React.MouseEventHandler<any>;
 }
 declare class NavbarLink extends React.Component<NavbarLinkProps> { }
 

types/react-bootstrap/lib/NavbarBrand.d.ts

@@ -1,7 +1,7 @@
 import * as React from 'react';
 
-declare class NavbarBrand extends React.Component<NavbarBrandProps> { }
-declare namespace NavbarBrand { }
-export = NavbarBrand
-
-interface NavbarBrandProps extends React.HTMLProps<NavbarBrand> { }
+declare namespace NavbarBrand {
+    export type  NavbarBrandProps = React.HTMLProps<NavbarBrand>;
+}
+declare class NavbarBrand extends React.Component<NavbarBrand.NavbarBrandProps> { }
+export = NavbarBrand;

types/react-bootstrap/lib/NavbarCollapse.d.ts

@@ -1,6 +1,7 @@
 import * as React from 'react';
 
-declare class NavbarCollapse extends React.Component<NavbarCollapseProps> { }
-declare namespace NavbarCollapse { }
+declare namespace NavbarCollapse {
+    export type NavbarCollapseProps = React.HTMLProps<NavbarCollapse>;
+}
+declare class NavbarCollapse extends React.Component<NavbarCollapse.NavbarCollapseProps> { }
 export = NavbarCollapse
-interface NavbarCollapseProps extends React.HTMLProps<NavbarCollapse> { }

types/react-bootstrap/lib/NavbarHeader.d.ts

@@ -1,6 +1,7 @@
 import * as React from 'react';
 
-declare class NavbarHeader extends React.Component<NavbarHeaderProps> { }
-declare namespace NavbarHeader { }
-export = NavbarHeader
-interface NavbarHeaderProps extends React.HTMLProps<NavbarHeader> { }
+declare namespace NavbarHeader {
+    export type NavbarHeaderProps = React.HTMLProps<NavbarHeader>;
+}
+declare class NavbarHeader extends React.Component<NavbarHeader.NavbarHeaderProps> { }
+export = NavbarHeader;

types/react-bootstrap/lib/NavbarToggle.d.ts

@@ -1,9 +1,9 @@
 import * as React from 'react';
 
-declare class NavbarToggle extends React.Component<NavbarToggleProps> { }
-declare namespace NavbarToggle { }
-export = NavbarToggle
-
-interface NavbarToggleProps extends React.Props<NavbarToggle> {
-  onClick?: React.MouseEventHandler<HTMLButtonElement>;
+declare namespace NavbarToggle {
+    export interface NavbarToggleProps extends React.HTMLProps<NavbarToggle> {
+        onClick?: React.MouseEventHandler<any>;
+    }
 }
+declare class NavbarToggle extends React.Component<NavbarToggle.NavbarToggleProps> { }
+export = NavbarToggle;

types/react-bootstrap/lib/Overlay.d.ts

@@ -1,19 +1,19 @@
 import * as React from 'react';
 import { TransitionCallbacks } from 'react-bootstrap';
 
-declare class Overlay extends React.Component<OverlayProps> { }
-declare namespace Overlay { }
-export = Overlay
-
-interface OverlayProps extends TransitionCallbacks {
-  // Optional
-  animation?: any; // TODO: Add more specific type
-  container?: any; // TODO: Add more specific type
-  containerPadding?: number; // TODO: Add more specific type
-  onHide?: Function;
-  placement?: string;
-  rootClose?: boolean;
-  show?: boolean;
-  target?: Function | React.ReactInstance;
-  shouldUpdatePosition?: boolean;
+declare namespace Overlay {
+    export interface OverlayProps extends TransitionCallbacks {
+        // Optional
+        animation?: any; // TODO: Add more specific type
+        container?: any; // TODO: Add more specific type
+        containerPadding?: number; // TODO: Add more specific type
+        onHide?: Function;
+        placement?: string;
+        rootClose?: boolean;
+        show?: boolean;
+        target?: Function | React.ReactInstance;
+        shouldUpdatePosition?: boolean;
+    }
 }
+declare class Overlay extends React.Component<Overlay.OverlayProps> { }
+export = Overlay;

types/react-bootstrap/lib/OverlayTrigger.d.ts

@@ -1,28 +1,28 @@
 import * as React from 'react';
 
-declare class OverlayTrigger extends React.Component<OverlayTriggerProps> { }
-declare namespace OverlayTrigger { }
-export = OverlayTrigger
+declare namespace OverlayTrigger {
+    export interface OverlayTriggerProps extends React.Props<OverlayTrigger> {
+        // Required
+        overlay: any; // TODO: Add more specific type
 
-interface OverlayTriggerProps extends React.Props<OverlayTrigger> {
-  // Required
-  overlay: any; // TODO: Add more specific type
-
-  // Optional
-  animation?: any; // TODO: Add more specific type
-  container?: any; // TODO: Add more specific type
-  containerPadding?: number;
-  defaultOverlayShown?: boolean;
-  delay?: number;
-  delayHide?: number;
-  delayShow?: number;
-  onEnter?: Function;
-  onEntered?: Function;
-  onEntering?: Function;
-  onExit?: Function;
-  onExited?: Function;
-  onExiting?: Function;
-  placement?: string;
-  rootClose?: boolean;
-  trigger?: string | string[];
+        // Optional
+        animation?: any; // TODO: Add more specific type
+        container?: any; // TODO: Add more specific type
+        containerPadding?: number;
+        defaultOverlayShown?: boolean;
+        delay?: number;
+        delayHide?: number;
+        delayShow?: number;
+        onEnter?: Function;
+        onEntered?: Function;
+        onEntering?: Function;
+        onExit?: Function;
+        onExited?: Function;
+        onExiting?: Function;
+        placement?: string;
+        rootClose?: boolean;
+        trigger?: string | string[];
+    }
 }
+declare class OverlayTrigger extends React.Component<OverlayTrigger.OverlayTriggerProps> { }
+export = OverlayTrigger;

types/react-bootstrap/lib/PageHeader.d.ts

@@ -1,6 +1,7 @@
 import * as React from 'react';
 
-declare class PageHeader extends React.Component<PageHeaderProps> { }
-declare namespace PageHeader { }
-export = PageHeader
-interface PageHeaderProps extends React.HTMLProps<PageHeader> { }
+declare namespace PageHeader {
+    export type PageHeaderProps = React.HTMLProps<PageHeader>;
+}
+declare class PageHeader extends React.Component<PageHeader.PageHeaderProps> { }
+export = PageHeader;

types/react-bootstrap/lib/PageItem.d.ts

@@ -1,3 +1,8 @@
 /** @deprecated since v0.30.0, should use <Pager.Item> instead of <PageItem>*/
-import * as PagerItem from './PagerItem';
-export = PagerItem;
+import PagerItem = require('./PagerItem');
+import { PagerItemProps } from './PagerItem';
+declare namespace PageItem {
+    export type PageItemProps = PagerItemProps;
+}
+declare class PageItem extends PagerItem { }
+export = PageItem;

types/react-bootstrap/lib/Pager.d.ts

@@ -2,12 +2,12 @@ import * as React from 'react';
 import { SelectCallback } from 'react-bootstrap';
 import * as PagerItem from './PagerItem';
 
-declare class Pager extends React.Component<PagerProps> {
-  public static Item: typeof PagerItem;
+declare namespace Pager {
+    export interface PagerProps extends React.HTMLProps<Pager> {
+        onSelect?: SelectCallback;
+    }
 }
-declare namespace Pager { }
-export = Pager
-
-interface PagerProps extends React.HTMLProps<Pager> {
-  onSelect?: SelectCallback;
+declare class Pager extends React.Component<Pager.PagerProps> {
+    static Item: typeof PagerItem;
 }
+export = Pager;

types/react-bootstrap/lib/PagerItem.d.ts

@@ -1,15 +1,15 @@
 import * as React from 'react';
 import { SelectCallback } from 'react-bootstrap';
 
-declare class PagerItem extends React.Component<PagerItemProps> { }
-declare namespace PagerItem { }
-export = PagerItem
-
-interface PagerItemProps extends React.HTMLProps<PagerItem> {
-  disabled?: boolean;
-  eventKey?: any;
-  next?: boolean;
-  onSelect?: SelectCallback;
-  previous?: boolean;
-  target?: string;
+declare namespace PagerItem {
+    export interface PagerItemProps extends React.HTMLProps<PagerItem> {
+        disabled?: boolean;
+        eventKey?: any;
+        next?: boolean;
+        onSelect?: SelectCallback;
+        previous?: boolean;
+        target?: string;
+    }
 }
+declare class PagerItem extends React.Component<PagerItem.PagerItemProps> { }
+export = PagerItem;

types/react-bootstrap/lib/Pagination.d.ts

@@ -1,22 +1,22 @@
 import * as React from 'react';
 import { Sizes, SelectCallback } from 'react-bootstrap';
 
-declare class Pagination extends React.Component<PaginationProps> { }
-declare namespace Pagination { }
-export = Pagination
-
-interface PaginationProps extends React.HTMLProps<Pagination> {
-  activePage?: number;
-  bsSize?: Sizes;
-  bsStyle?: string;
-  boundaryLinks?: boolean;
-  buttonComponentClass?: React.ReactType;
-  ellipsis?: React.ReactNode;
-  first?: React.ReactNode;
-  items?: number;
-  last?: React.ReactNode;
-  maxButtons?: number;
-  next?: React.ReactNode;
-  onSelect?: SelectCallback;
-  prev?: React.ReactNode;
+declare namespace Pagination {
+    export interface PaginationProps extends React.HTMLProps<Pagination> {
+        activePage?: number;
+        bsSize?: Sizes;
+        bsStyle?: string;
+        boundaryLinks?: boolean;
+        buttonComponentClass?: React.ReactType;
+        ellipsis?: React.ReactNode;
+        first?: React.ReactNode;
+        items?: number;
+        last?: React.ReactNode;
+        maxButtons?: number;
+        next?: React.ReactNode;
+        onSelect?: SelectCallback;
+        prev?: React.ReactNode;
+    }
 }
+declare class Pagination extends React.Component<Pagination.PaginationProps> { }
+export = Pagination;

types/react-bootstrap/lib/PaginationButton.d.ts

@@ -1,16 +1,16 @@
 import * as React from 'react';
 import { SelectCallback } from 'react-bootstrap';
 
-declare class PaginationButton extends React.Component<PaginationButtonProps> { }
-declare namespace PaginationButton { }
-export = PaginationButton
-
-interface PaginationButtonProps extends React.HTMLProps<PaginationButton> {
-  componentClass?: React.ReactType;
-  className?: string;
-  eventKey?: any;
-  onSelect?: SelectCallback;
-  disabled?: boolean;
-  active?: boolean;
-  onClick: React.MouseEventHandler<{}>;
+declare namespace PaginationButton {
+    export interface PaginationButtonProps extends React.HTMLProps<PaginationButton> {
+        componentClass?: React.ReactType;
+        className?: string;
+        eventKey?: any;
+        onSelect?: SelectCallback;
+        disabled?: boolean;
+        active?: boolean;
+        onClick: React.MouseEventHandler<{}>;
+    }
 }
+declare class PaginationButton extends React.Component<PaginationButton.PaginationButtonProps> { }
+export = PaginationButton;

types/react-bootstrap/lib/Panel.d.ts

@@ -1,19 +1,19 @@
 import * as React from 'react';
 import { TransitionCallbacks, Sizes, SelectCallback } from 'react-bootstrap';
 
-declare class Panel extends React.Component<PanelProps> { }
-declare namespace Panel { }
-export = Panel
-
-interface PanelProps extends TransitionCallbacks, React.HTMLProps<Panel> {
-  bsClass?: string;
-  bsSize?: Sizes;
-  bsStyle?: string;
-  collapsible?: boolean;
-  defaultExpanded?: boolean;
-  eventKey?: any;
-  expanded?: boolean;
-  footer?: React.ReactNode;
-  header?: React.ReactNode;
-  onSelect?: SelectCallback;
+declare namespace Panel {
+    export interface PanelProps extends TransitionCallbacks, React.HTMLProps<Panel> {
+        bsClass?: string;
+        bsSize?: Sizes;
+        bsStyle?: string;
+        collapsible?: boolean;
+        defaultExpanded?: boolean;
+        eventKey?: any;
+        expanded?: boolean;
+        footer?: React.ReactNode;
+        header?: React.ReactNode;
+        onSelect?: SelectCallback;
+    }
 }
+declare class Panel extends React.Component<Panel.PanelProps> { }
+export = Panel;

types/react-bootstrap/lib/PanelGroup.d.ts

@@ -1,15 +1,15 @@
 import * as React from 'react';
 import { Sizes, SelectCallback } from 'react-bootstrap';
 
-declare class PanelGroup extends React.Component<PanelGroupProps> { }
-declare namespace PanelGroup { }
-export = PanelGroup
-
-interface PanelGroupProps extends React.HTMLProps<PanelGroup> {
-  accordion?: boolean;
-  activeKey?: any;
-  bsSize?: Sizes;
-  bsStyle?: string;
-  defaultActiveKey?: any;
-  onSelect?: SelectCallback;
+declare namespace PanelGroup {
+    export interface PanelGroupProps extends React.HTMLProps<PanelGroup> {
+        accordion?: boolean;
+        activeKey?: any;
+        bsSize?: Sizes;
+        bsStyle?: string;
+        defaultActiveKey?: any;
+        onSelect?: SelectCallback;
+    }
 }
+declare class PanelGroup extends React.Component<PanelGroup.PanelGroupProps> { }
+export = PanelGroup;

types/react-bootstrap/lib/Popover.d.ts

@@ -1,17 +1,17 @@
 import * as React from 'react';
 import { Sizes } from 'react-bootstrap';
 
-declare class Popover extends React.Component<PopoverProps> { }
-declare namespace Popover { }
-export = Popover
-
-interface PopoverProps extends React.HTMLProps<Popover> {
-  // Optional
-  arrowOffsetLeft?: number | string;
-  arrowOffsetTop?: number | string;
-  bsSize?: Sizes;
-  bsStyle?: string;
-  placement?: string;
-  positionLeft?: number | string; // String support added since v0.30.0
-  positionTop?: number | string; // String support added since v0.30.0
+declare namespace Popover {
+    export interface PopoverProps extends React.HTMLProps<Popover> {
+        // Optional
+        arrowOffsetLeft?: number | string;
+        arrowOffsetTop?: number | string;
+        bsSize?: Sizes;
+        bsStyle?: string;
+        placement?: string;
+        positionLeft?: number | string; // String support added since v0.30.0
+        positionTop?: number | string; // String support added since v0.30.0
+    }
 }
+declare class Popover extends React.Component<Popover.PopoverProps> { }
+export = Popover;

types/react-bootstrap/lib/ProgressBar.d.ts

@@ -1,19 +1,19 @@
 import * as React from 'react';
 import { Sizes } from 'react-bootstrap';
 
-declare class ProgressBar extends React.Component<ProgressBarProps> { }
-declare namespace ProgressBar { }
-export = ProgressBar
-
-interface ProgressBarProps extends React.HTMLProps<ProgressBar> {
-  // Optional
-  active?: boolean;
-  bsSize?: Sizes;
-  bsStyle?: string;
-  interpolatedClass?: any; // TODO: Add more specific type
-  max?: number;
-  min?: number;
-  now?: number;
-  srOnly?: boolean;
-  striped?: boolean;
+declare namespace ProgressBar {
+    export interface ProgressBarProps extends React.HTMLProps<ProgressBar> {
+        // Optional
+        active?: boolean;
+        bsSize?: Sizes;
+        bsStyle?: string;
+        interpolatedClass?: any; // TODO: Add more specific type
+        max?: number;
+        min?: number;
+        now?: number;
+        srOnly?: boolean;
+        striped?: boolean;
+    }
 }
+declare class ProgressBar extends React.Component<ProgressBar.ProgressBarProps> { }
+export = ProgressBar;

types/react-bootstrap/lib/Radio.d.ts

@@ -1,13 +1,14 @@
 import * as React from 'react';
 
-declare class Radio extends React.Component<RadioProps> { }
-declare namespace Radio { }
-export = Radio
+declare namespace Radio {
+    export interface RadioProps extends React.HTMLProps<Radio> {
+        bsClass?: string;
+        disabled?: boolean;
+        inline?: boolean;
+        inputRef?: (instance: HTMLInputElement) => void;
+        validationState?: "success" | "warning" | "error";
+    }
 
-interface RadioProps extends React.HTMLProps<Radio> {
-  bsClass?: string;
-  disabled?: boolean;
-  inline?: boolean;
-  inputRef?: (instance: HTMLInputElement) => void;
-  validationState?: "success" | "warning" | "error";
 }
+declare class Radio extends React.Component<Radio.RadioProps> { }
+export = Radio;

types/react-bootstrap/lib/ResponsiveEmbed.d.ts

@@ -1,11 +1,11 @@
 import * as React from 'react';
 
-declare class ResponsiveEmbed extends React.Component<ResponsiveEmbedProps> { }
-declare namespace ResponsiveEmbed { }
-export = ResponsiveEmbed
-
-interface ResponsiveEmbedProps extends React.HTMLProps<ResponsiveEmbed> {
-  a16by9?: boolean;
-  a4by3?: boolean;
-  bsClass?: string;
+declare namespace ResponsiveEmbed {
+    export interface ResponsiveEmbedProps extends React.HTMLProps<ResponsiveEmbed> {
+        a16by9?: boolean;
+        a4by3?: boolean;
+        bsClass?: string;
+    }
 }
+declare class ResponsiveEmbed extends React.Component<ResponsiveEmbed.ResponsiveEmbedProps> { }
+export = ResponsiveEmbed;

types/react-bootstrap/lib/Row.d.ts

@@ -1,9 +1,9 @@
 import * as React from 'react';
 
-declare class Row extends React.Component<RowProps> { }
-declare namespace Row { }
-export = Row
-
-interface RowProps extends React.HTMLProps<Row> {
-  componentClass?: React.ReactType;
+declare namespace Row {
+    export interface RowProps extends React.HTMLProps<Row> {
+        componentClass?: React.ReactType;
+    }
 }
+declare class Row extends React.Component<Row.RowProps> { }
+export = Row;

types/react-bootstrap/lib/SafeAnchor.d.ts

@@ -1,13 +1,13 @@
 import * as React from 'react';
 
-declare class SafeAnchor extends React.Component<SafeAnchorProps> { }
-declare namespace SafeAnchor { }
-export = SafeAnchor
-
-interface SafeAnchorProps extends React.HTMLProps<SafeAnchor> {
-  href?: string;
-  onClick?: React.MouseEventHandler<{}>;
-  disabled?: boolean;
-  role?: string;
-  componentClass?: React.ReactType;
+declare namespace SafeAnchor {
+    export interface SafeAnchorProps extends React.HTMLProps<SafeAnchor> {
+        href?: string;
+        onClick?: React.MouseEventHandler<{}>;
+        disabled?: boolean;
+        role?: string;
+        componentClass?: React.ReactType;
+    }
 }
+declare class SafeAnchor extends React.Component<SafeAnchor.SafeAnchorProps> { }
+export = SafeAnchor;

types/react-bootstrap/lib/SplitButton.d.ts

@@ -1,14 +1,14 @@
 import * as React from 'react';
 import { Sizes } from 'react-bootstrap';
 
-declare class SplitButton extends React.Component<SplitButtonProps> { }
-declare namespace SplitButton { }
-export = SplitButton
-
-interface SplitButtonProps extends React.HTMLProps<SplitButton> {
-  bsStyle?: string;
-  bsSize?: Sizes;
-  dropdownTitle?: any; // TODO: Add more specific type
-  dropup?: boolean;
-  pullRight?: boolean;
+declare namespace SplitButton {
+    export interface SplitButtonProps extends React.HTMLProps<SplitButton> {
+        bsStyle?: string;
+        bsSize?: Sizes;
+        dropdownTitle?: any; // TODO: Add more specific type
+        dropup?: boolean;
+        pullRight?: boolean;
+    }
 }
+declare class SplitButton extends React.Component<SplitButton.SplitButtonProps> { }
+export = SplitButton;

types/react-bootstrap/lib/SplitToggle.d.ts

@@ -1,7 +1,8 @@
 import * as React from 'react';
 import { DropdownToggleProps } from './DropdownToggle';
 
-declare class SplitToggle extends React.Component<SplitToggleProps> { }
-declare namespace SplitToggle { }
-export = SplitToggle
-interface SplitToggleProps extends DropdownToggleProps, React.HTMLProps<SplitToggle> { }
+declare namespace SplitToggle {
+    export type SplitToggleProps = DropdownToggleProps & React.HTMLProps<SplitToggle>;
+}
+declare class SplitToggle extends React.Component<SplitToggle.SplitToggleProps> { }
+export = SplitToggle;

types/react-bootstrap/lib/Tab.d.ts

@@ -4,19 +4,19 @@ import * as TabContainer from './TabContainer';
 import * as TabPane from './TabPane';
 import * as TabContent from './TabContent';
 
-declare class Tab extends React.Component<TabProps> {
-  public static Container: typeof TabContainer;
-  public static Content: typeof TabContent;
-  public static Pane: typeof TabPane;
+declare namespace Tab {
+    export interface TabProps extends TransitionCallbacks, React.HTMLProps<Tab> {
+        animation?: boolean;
+        'aria-labelledby'?: string;
+        bsClass?: string;
+        eventKey?: any; // TODO: Add more specific type
+        unmountOnExit?: boolean;
+        tabClassName?: string;
+    }
 }
-declare namespace Tab { }
-export = Tab
-
-interface TabProps extends TransitionCallbacks, React.HTMLProps<Tab> {
-  animation?: boolean;
-  'aria-labelledby'?: string;
-  bsClass?: string;
-  eventKey?: any; // TODO: Add more specific type
-  unmountOnExit?: boolean;
-  tabClassName?: string;
+declare class Tab extends React.Component<Tab.TabProps> {
+    static Container: typeof TabContainer;
+    static Content: typeof TabContent;
+    static Pane: typeof TabPane;
 }
+export = Tab;

types/react-bootstrap/lib/TabContainer.d.ts

@@ -1,11 +1,11 @@
 import * as React from 'react';
 
-declare class TabContainer extends React.Component<TabContainerProps> { }
-declare namespace TabContainer { }
-export = TabContainer
-
-interface TabContainerProps extends React.HTMLAttributes<TabContainer> {
-  activeKey?: any;
-  defaultActiveKey?: any;
-  generateChildId?: (eventKey: any, type: any) => string;
+declare namespace TabContainer {
+    export interface TabContainerProps extends React.HTMLAttributes<TabContainer> {
+        activeKey?: any;
+        defaultActiveKey?: any;
+        generateChildId?: (eventKey: any, type: any) => string;
+    }
 }
+declare class TabContainer extends React.Component<TabContainer.TabContainerProps> { }
+export = TabContainer;

types/react-bootstrap/lib/TabContent.d.ts

@@ -1,12 +1,12 @@
 import * as React from 'react';
 
-declare class TabContent extends React.Component<TabContentProps> { }
-declare namespace TabContent { }
-export = TabContent
-
-interface TabContentProps extends React.HTMLProps<TabContent> {
-  componentClass?: React.ReactType,
-  animation?: boolean | React.ReactType;
-  mountOnEnter?: boolean;
-  unmountOnExit?: boolean;
+declare namespace TabContent {
+    export interface TabContentProps extends React.HTMLProps<TabContent> {
+        componentClass?: React.ReactType,
+        animation?: boolean | React.ReactType;
+        mountOnEnter?: boolean;
+        unmountOnExit?: boolean;
+    }
 }
+declare class TabContent extends React.Component<TabContent.TabContentProps> { }
+export = TabContent;

types/react-bootstrap/lib/TabPane.d.ts

@@ -1,14 +1,14 @@
 import * as React from 'react';
 import { TransitionCallbacks } from 'react-bootstrap';
 
-declare class TabPane extends React.Component<TabPaneProps> { }
-declare namespace TabPane { }
-export = TabPane
-
-interface TabPaneProps extends TransitionCallbacks, React.HTMLProps<TabPane> {
-  animation?: boolean | React.ComponentClass<any>;
-  'aria-labelledby'?: string;
-  bsClass?: string;
-  eventKey?: any;
-  unmountOnExit?: boolean;
+declare namespace TabPane {
+    export interface TabPaneProps extends TransitionCallbacks, React.HTMLProps<TabPane> {
+        animation?: boolean | React.ComponentClass<any>;
+        'aria-labelledby'?: string;
+        bsClass?: string;
+        eventKey?: any;
+        unmountOnExit?: boolean;
+    }
 }
+declare class TabPane extends React.Component<TabPane.TabPaneProps> { }
+export = TabPane;

types/react-bootstrap/lib/Table.d.ts

@@ -1,15 +1,15 @@
 import * as React from 'react';
 
-declare class Table extends React.Component<TableProps> { }
-declare namespace Table { }
-export = Table
-
-interface TableProps extends React.HTMLProps<Table> {
-  bordered?: boolean;
-  condensed?: boolean;
-  hover?: boolean;
-  responsive?: boolean;
-  striped?: boolean;
-  fill?: boolean;
-  bsClass?: string;
+declare namespace Table {
+    export interface TableProps extends React.HTMLProps<Table> {
+        bordered?: boolean;
+        condensed?: boolean;
+        hover?: boolean;
+        responsive?: boolean;
+        striped?: boolean;
+        fill?: boolean;
+        bsClass?: string;
+    }
 }
+declare class Table extends React.Component<Table.TableProps> { }
+export = Table;

types/react-bootstrap/lib/Tabs.d.ts

@@ -1,19 +1,19 @@
 import * as React from 'react';
 import { SelectCallback } from 'react-bootstrap';
 
-declare class Tabs extends React.Component<TabsProps> { }
-declare namespace Tabs { }
-export = Tabs
-
-interface TabsProps extends React.HTMLProps<Tabs> {
-  activeKey?: any;
-  animation?: boolean;
-  bsStyle?: string;
-  defaultActiveKey?: any;
-  onSelect?: SelectCallback;
-  paneWidth?: any; // TODO: Add more specific type
-  position?: string;
-  tabWidth?: any; // TODO: Add more specific type
-  unmountOnExit?: boolean;
-  justified?: boolean;
+declare namespace Tabs {
+    export interface TabsProps extends React.HTMLProps<Tabs> {
+        activeKey?: any;
+        animation?: boolean;
+        bsStyle?: string;
+        defaultActiveKey?: any;
+        onSelect?: SelectCallback;
+        paneWidth?: any; // TODO: Add more specific type
+        position?: string;
+        tabWidth?: any; // TODO: Add more specific type
+        unmountOnExit?: boolean;
+        justified?: boolean;
+    }
 }
+declare class Tabs extends React.Component<Tabs.TabsProps> { }
+export = Tabs;

types/react-bootstrap/lib/Thumbnail.d.ts

@@ -1,11 +1,11 @@
 import * as React from 'react';
 import { Sizes } from 'react-bootstrap';
 
-declare class Thumbnail extends React.Component<ThumbnailProps> { }
-declare namespace Thumbnail { }
-export = Thumbnail
-
-interface ThumbnailProps extends React.HTMLProps<Thumbnail> {
-  bsSize?: Sizes;
-  bsStyle?: string;
+declare namespace Thumbnail {
+    export interface ThumbnailProps extends React.HTMLProps<Thumbnail> {
+        bsSize?: Sizes;
+        bsStyle?: string;
+    }
 }
+declare class Thumbnail extends React.Component<Thumbnail.ThumbnailProps> { }
+export = Thumbnail;

types/react-bootstrap/lib/Tooltip.d.ts

@@ -1,17 +1,17 @@
 import * as React from 'react';
 import { Sizes } from 'react-bootstrap';
 
-declare class Tooltip extends React.Component<TooltipProps> { }
-declare namespace Tooltip { }
-export = Tooltip
-
-interface TooltipProps extends React.HTMLProps<Tooltip> {
-  // Optional
-  arrowOffsetLeft?: number | string;
-  arrowOffsetTop?: number | string;
-  bsSize?: Sizes;
-  bsStyle?: string;
-  placement?: string;
-  positionLeft?: number;
-  positionTop?: number;
+declare namespace Tooltip {
+    export interface TooltipProps extends React.HTMLProps<Tooltip> {
+        // Optional
+        arrowOffsetLeft?: number | string;
+        arrowOffsetTop?: number | string;
+        bsSize?: Sizes;
+        bsStyle?: string;
+        placement?: string;
+        positionLeft?: number;
+        positionTop?: number;
+    }
 }
+declare class Tooltip extends React.Component<Tooltip.TooltipProps> { }
+export = Tooltip;

types/react-bootstrap/lib/Well.d.ts

@@ -1,11 +1,11 @@
 import * as React from 'react';
 import { Sizes } from 'react-bootstrap';
 
-declare class Well extends React.Component<WellProps> { }
-declare namespace Well { }
-export = Well
-
-interface WellProps extends React.HTMLProps<Well> {
-  bsSize?: Sizes;
-  bsStyle?: string;
+declare namespace Well {
+    export interface WellProps extends React.HTMLProps<Well> {
+        bsSize?: Sizes;
+        bsStyle?: string;
+    }
 }
+declare class Well extends React.Component<Well.WellProps> { }
+export = Well;

types/react-bootstrap/lib/index.d.ts

@@ -1,178 +1,349 @@
-import * as Accordion from './Accordion';
-import * as Alert from './Alert';
-import * as Badge from './Badge';
-import * as Breadcrumb from './Breadcrumb';
-import * as BreadcrumbItem from './BreadcrumbItem';
-import * as Button from './Button';
-import * as ButtonGroup from './ButtonGroup';
-import * as ButtonToolbar from './ButtonToolbar';
-import * as Carousel from './Carousel';
-import * as CarouselCaption from './CarouselCaption';
-import * as CarouselItem from './CarouselItem';
-import * as Checkbox from './Checkbox';
-import * as Clearfix from './Clearfix';
-import * as Col from './Col';
-import * as Collapse from './Collapse';
-import * as ControlLabel from './ControlLabel';
-import * as Dropdown from './Dropdown';
-import * as DropdownButton from './DropdownButton';
-import * as DropdownMenu from './DropdownMenu';
-import * as DropdownToggle from './DropdownToggle';
-import * as Fade from './Fade';
-import * as Form from './Form';
-import * as FormControl from './FormControl';
-import * as FormControlFeedback from './FormControlFeedback';
-import * as FormControlStatic from './FormControlStatic';
-import * as FormGroup from './FormGroup';
-import * as Glyphicon from './Glyphicon';
-import * as Grid from './Grid';
-import * as HelpBlock from './HelpBlock';
-import * as Image from './Image';
-import * as InputGroup from './InputGroup';
-import * as InputGroupAddon from './InputGroupAddon';
-import * as InputGroupButton from './InputGroupButton';
-import * as Jumbotron from './Jumbotron';
-import * as Label from './Label';
-import * as ListGroup from './ListGroup';
-import * as ListGroupItem from './ListGroupItem';
-import * as Media from './Media';
-import * as MediaBody from './MediaBody';
-import * as MediaHeading from './MediaHeading';
-import * as MediaLeft from './MediaLeft';
-import * as MediaList from './MediaList';
-import * as MediaListItem from './MediaListItem';
-import * as MediaRight from './MediaRight';
-import * as MenuItem from './MenuItem';
-import * as Modal from './Modal';
-import * as ModalBody from './ModalBody';
-import * as ModalDialog from './ModalDialog';
-import * as ModalFooter from './ModalFooter';
-import * as ModalHeader from './ModalHeader';
-import * as ModalTitle from './ModalTitle';
-import * as Nav from './Nav';
-import * as Navbar from './Navbar';
-import * as NavbarBrand from './NavbarBrand';
-import * as NavbarCollapse from './NavbarCollapse';
-import * as NavbarHeader from './NavbarHeader';
-import * as NavbarToggle from './NavbarToggle';
-import * as NavDropdown from './NavDropdown';
-import * as NavItem from './NavItem';
-import * as Overlay from './Overlay';
-import * as OverlayTrigger from './OverlayTrigger';
-import * as PageHeader from './PageHeader';
-import * as PageItem from './PageItem';
-import * as Pager from './Pager';
-import * as PagerItem from './PagerItem';
-import * as Pagination from './Pagination';
-import * as PaginationButton from './PaginationButton';
-import * as Panel from './Panel';
-import * as PanelGroup from './PanelGroup';
-import * as Popover from './Popover';
-import * as ProgressBar from './ProgressBar';
-import * as Radio from './Radio';
-import * as ResponsiveEmbed from './ResponsiveEmbed';
-import * as Row from './Row';
-import * as SafeAnchor from './SafeAnchor';
-import * as SplitButton from './SplitButton';
-import * as SplitToggle from './SplitToggle';
-import * as Tab from './Tab';
-import * as TabContainer from './TabContainer';
-import * as TabContent from './TabContent';
-import * as Table from './Table';
-import * as TabPane from './TabPane';
-import * as Tabs from './Tabs';
-import * as Thumbnail from './Thumbnail';
-import * as Tooltip from './Tooltip';
-import * as Well from './Well';
-
+import Accordion = require('./Accordion');
+import { AccordionProps } from './Accordion';
+import Alert = require('./Alert');
+import { AlertProps } from './Alert';
+import Badge = require('./Badge');
+import { BadgeProps } from './Badge';
+import Breadcrumb = require('./Breadcrumb');
+import { BreadcrumbProps } from './Breadcrumb';
+import BreadcrumbItem = require('./BreadcrumbItem');
+import { BreadcrumbItemProps } from './BreadcrumbItem';
+import Button = require('./Button');
+import { ButtonProps } from './Button';
+import ButtonGroup = require('./ButtonGroup');
+import { ButtonGroupProps } from './ButtonGroup';
+import ButtonToolbar = require('./ButtonToolbar');
+import { ButtonToolbarProps } from './ButtonToolbar';
+import Carousel = require('./Carousel');
+import { CarouselProps } from './Carousel';
+import CarouselCaption = require('./CarouselCaption');
+import { CarouselCaptionProps } from './CarouselCaption';
+import CarouselItem = require('./CarouselItem');
+import { CarouselItemProps } from './CarouselItem';
+import Checkbox = require('./Checkbox');
+import { CheckboxProps } from './Checkbox';
+import Clearfix = require('./Clearfix');
+import { ClearfixProps } from './Clearfix';
+import Col = require('./Col');
+import { ColProps } from './Col';
+import Collapse = require('./Collapse');
+import { CollapseProps } from './Collapse';
+import ControlLabel = require('./ControlLabel');
+import { ControlLabelProps } from './ControlLabel';
+import Dropdown = require('./Dropdown');
+import { DropdownProps } from './Dropdown';
+import DropdownButton = require('./DropdownButton');
+import { DropdownButtonProps } from './DropdownButton';
+import DropdownMenu = require('./DropdownMenu');
+import { DropdownMenuProps } from './DropdownMenu';
+import DropdownToggle = require('./DropdownToggle');
+import { DropdownToggleProps } from './DropdownToggle';
+import Fade = require('./Fade');
+import { FadeProps } from './Fade';
+import Form = require('./Form');
+import { FormProps } from './Form';
+import FormControl = require('./FormControl');
+import { FormControlProps } from './FormControl';
+import FormControlFeedback = require('./FormControlFeedback');
+import { FormControlFeedbackProps } from './FormControlFeedback';
+import FormControlStatic = require('./FormControlStatic');
+import { FormControlStaticProps } from './FormControlStatic';
+import FormGroup = require('./FormGroup');
+import { FormGroupProps } from './FormGroup';
+import Glyphicon = require('./Glyphicon');
+import { GlyphiconProps } from './Glyphicon';
+import Grid = require('./Grid');
+import { GridProps } from './Grid';
+import HelpBlock = require('./HelpBlock');
+import { HelpBlockProps } from './HelpBlock';
+import Image = require('./Image');
+import { ImageProps } from './Image';
+import InputGroup = require('./InputGroup');
+import { InputGroupProps } from './InputGroup';
+import InputGroupAddon = require('./InputGroupAddon');
+import { InputGroupAddonProps } from './InputGroupAddon';
+import InputGroupButton = require('./InputGroupButton');
+import { InputGroupButtonProps } from './InputGroupButton';
+import Jumbotron = require('./Jumbotron');
+import { JumbotronProps } from './Jumbotron';
+import Label = require('./Label');
+import { LabelProps } from './Label';
+import ListGroup = require('./ListGroup');
+import { ListGroupProps } from './ListGroup';
+import ListGroupItem = require('./ListGroupItem');
+import { ListGroupItemProps } from './ListGroupItem';
+import Media = require('./Media');
+import { MediaProps } from './Media';
+import MediaBody = require('./MediaBody');
+import { MediaBodyProps } from './MediaBody';
+import MediaHeading = require('./MediaHeading');
+import { MediaHeadingProps } from './MediaHeading';
+import MediaLeft = require('./MediaLeft');
+import { MediaLeftProps } from './MediaLeft';
+import MediaList = require('./MediaList');
+import { MediaListProps } from './MediaList';
+import MediaListItem = require('./MediaListItem');
+import { MediaListItemProps } from './MediaListItem';
+import MediaRight = require('./MediaRight');
+import { MediaRightProps } from './MediaRight';
+import MenuItem = require('./MenuItem');
+import { MenuItemProps } from './MenuItem';
+import Modal = require('./Modal');
+import { ModalProps } from './Modal';
+import ModalBody = require('./ModalBody');
+import { ModalBodyProps } from './ModalBody';
+import ModalDialog = require('./ModalDialog');
+import { ModalDialogProps } from './ModalDialog';
+import ModalFooter = require('./ModalFooter');
+import { ModalFooterProps } from './ModalFooter';
+import ModalHeader = require('./ModalHeader');
+import { ModalHeaderProps } from './ModalHeader';
+import ModalTitle = require('./ModalTitle');
+import { ModalTitleProps } from './ModalTitle';
+import Nav = require('./Nav');
+import { NavProps } from './Nav';
+import Navbar = require('./Navbar');
+import { NavbarProps } from './Navbar';
+import NavbarBrand = require('./NavbarBrand');
+import { NavbarBrandProps } from './NavbarBrand';
+import NavbarCollapse = require('./NavbarCollapse');
+import { NavbarCollapseProps } from './NavbarCollapse';
+import NavbarHeader = require('./NavbarHeader');
+import { NavbarHeaderProps } from './NavbarHeader';
+import NavbarToggle = require('./NavbarToggle');
+import { NavbarToggleProps } from './NavbarToggle';
+import NavDropdown = require('./NavDropdown');
+import { NavDropdownProps } from './NavDropdown';
+import NavItem = require('./NavItem');
+import { NavItemProps } from './NavItem';
+import Overlay = require('./Overlay');
+import { OverlayProps } from './Overlay';
+import OverlayTrigger = require('./OverlayTrigger');
+import { OverlayTriggerProps } from './OverlayTrigger';
+import PageHeader = require('./PageHeader');
+import { PageHeaderProps } from './PageHeader';
+import PageItem = require('./PageItem');
+import { PageItemProps } from './PageItem';
+import Pager = require('./Pager');
+import { PagerProps } from './Pager';
+import PagerItem = require('./PagerItem');
+import { PagerItemProps } from './PagerItem';
+import Pagination = require('./Pagination');
+import { PaginationProps } from './Pagination';
+import PaginationButton = require('./PaginationButton');
+import { PaginationButtonProps } from './PaginationButton';
+import Panel = require('./Panel');
+import { PanelProps } from './Panel';
+import PanelGroup = require('./PanelGroup');
+import { PanelGroupProps } from './PanelGroup';
+import Popover = require('./Popover');
+import { PopoverProps } from './Popover';
+import ProgressBar = require('./ProgressBar');
+import { ProgressBarProps } from './ProgressBar';
+import Radio = require('./Radio');
+import { RadioProps } from './Radio';
+import ResponsiveEmbed = require('./ResponsiveEmbed');
+import { ResponsiveEmbedProps } from './ResponsiveEmbed';
+import Row = require('./Row');
+import { RowProps } from './Row';
+import SafeAnchor = require('./SafeAnchor');
+import { SafeAnchorProps } from './SafeAnchor';
+import SplitButton = require('./SplitButton');
+import { SplitButtonProps } from './SplitButton';
+import SplitToggle = require('./SplitToggle');
+import { SplitToggleProps } from './SplitToggle';
+import Tab = require('./Tab');
+import { TabProps } from './Tab';
+import TabContainer = require('./TabContainer');
+import { TabContainerProps } from './TabContainer';
+import TabContent = require('./TabContent');
+import { TabContentProps } from './TabContent';
+import Table = require('./Table');
+import { TableProps } from './Table';
+import TabPane = require('./TabPane');
+import { TabPaneProps } from './TabPane';
+import Tabs = require('./Tabs');
+import { TabsProps } from './Tabs';
+import Thumbnail = require('./Thumbnail');
+import { ThumbnailProps } from './Thumbnail';
+import Tooltip = require('./Tooltip');
+import { TooltipProps } from './Tooltip';
+import Well = require('./Well');
+import { WellProps } from './Well';
 import * as utils from './utils';
 
 export {
-  Accordion,
-  Alert,
-  Badge,
-  Breadcrumb,
-  BreadcrumbItem,
-  Button,
-  ButtonGroup,
-  ButtonToolbar,
-  Carousel,
-  CarouselCaption,
-  CarouselItem,
-  Checkbox,
-  Clearfix,
-  Col,
-  Collapse,
-  ControlLabel,
-  Dropdown,
-  DropdownButton,
-  DropdownMenu,
-  DropdownToggle,
-  Fade,
-  Form,
-  FormControl,
-  FormControlFeedback,
-  FormControlStatic,
-  FormGroup,
-  Glyphicon,
-  Grid,
-  HelpBlock,
-  Image,
-  InputGroup,
-  InputGroupAddon,
-  InputGroupButton,
-  Jumbotron,
-  Label,
-  ListGroup,
-  ListGroupItem,
-  Media,
-  MediaBody,
-  MediaHeading,
-  MediaLeft,
-  MediaList,
-  MediaListItem,
-  MediaRight,
-  MenuItem,
-  Modal,
-  ModalBody,
-  ModalDialog,
-  ModalFooter,
-  ModalHeader,
-  ModalTitle,
-  Nav,
-  Navbar,
-  NavbarBrand,
-  NavbarCollapse,
-  NavbarHeader,
-  NavbarToggle,
-  NavDropdown,
-  NavItem,
-  Overlay,
-  OverlayTrigger,
-  PageHeader,
-  PageItem,
-  Pager,
-  PagerItem,
-  Pagination,
-  PaginationButton,
-  Panel,
-  PanelGroup,
-  Popover,
-  ProgressBar,
-  Radio,
-  ResponsiveEmbed,
-  Row,
-  SafeAnchor,
-  SplitButton,
-  SplitToggle,
-  Tab,
-  TabContainer,
-  TabContent,
-  Table,
-  TabPane,
-  Tabs,
-  Thumbnail,
-  Tooltip,
-  Well,
-  utils,
+    Accordion,
+    AccordionProps,
+    Alert,
+    AlertProps,
+    Badge,
+    BadgeProps,
+    Breadcrumb,
+    BreadcrumbProps,
+    BreadcrumbItem,
+    BreadcrumbItemProps,
+    Button,
+    ButtonProps,
+    ButtonGroup,
+    ButtonGroupProps,
+    ButtonToolbar,
+    ButtonToolbarProps,
+    Carousel,
+    CarouselProps,
+    CarouselCaption,
+    CarouselCaptionProps,
+    CarouselItem,
+    CarouselItemProps,
+    Checkbox,
+    CheckboxProps,
+    Clearfix,
+    ClearfixProps,
+    Col,
+    ColProps,
+    Collapse,
+    CollapseProps,
+    ControlLabel,
+    ControlLabelProps,
+    Dropdown,
+    DropdownProps,
+    DropdownButton,
+    DropdownButtonProps,
+    DropdownMenu,
+    DropdownMenuProps,
+    DropdownToggle,
+    DropdownToggleProps,
+    Fade,
+    FadeProps,
+    Form,
+    FormProps,
+    FormControl,
+    FormControlProps,
+    FormControlFeedback,
+    FormControlFeedbackProps,
+    FormControlStatic,
+    FormControlStaticProps,
+    FormGroup,
+    FormGroupProps,
+    Glyphicon,
+    GlyphiconProps,
+    Grid,
+    GridProps,
+    HelpBlock,
+    HelpBlockProps,
+    Image,
+    ImageProps,
+    InputGroup,
+    InputGroupProps,
+    InputGroupAddon,
+    InputGroupAddonProps,
+    InputGroupButton,
+    InputGroupButtonProps,
+    Jumbotron,
+    JumbotronProps,
+    Label,
+    LabelProps,
+    ListGroup,
+    ListGroupProps,
+    ListGroupItem,
+    ListGroupItemProps,
+    Media,
+    MediaProps,
+    MediaBody,
+    MediaBodyProps,
+    MediaHeading,
+    MediaHeadingProps,
+    MediaLeft,
+    MediaLeftProps,
+    MediaList,
+    MediaListProps,
+    MediaListItem,
+    MediaListItemProps,
+    MediaRight,
+    MediaRightProps,
+    MenuItem,
+    MenuItemProps,
+    Modal,
+    ModalProps,
+    ModalBody,
+    ModalBodyProps,
+    ModalDialog,
+    ModalDialogProps,
+    ModalFooter,
+    ModalFooterProps,
+    ModalHeader,
+    ModalHeaderProps,
+    ModalTitle,
+    ModalTitleProps,
+    Nav,
+    NavProps,
+    Navbar,
+    NavbarProps,
+    NavbarBrand,
+    NavbarBrandProps,
+    NavbarCollapse,
+    NavbarCollapseProps,
+    NavbarHeader,
+    NavbarHeaderProps,
+    NavbarToggle,
+    NavbarToggleProps,
+    NavDropdown,
+    NavDropdownProps,
+    NavItem,
+    NavItemProps,
+    Overlay,
+    OverlayProps,
+    OverlayTrigger,
+    OverlayTriggerProps,
+    PageHeader,
+    PageHeaderProps,
+    PageItem,
+    PageItemProps,
+    Pager,
+    PagerProps,
+    PagerItem,
+    PagerItemProps,
+    Pagination,
+    PaginationProps,
+    PaginationButton,
+    PaginationButtonProps,
+    Panel,
+    PanelProps,
+    PanelGroup,
+    PanelGroupProps,
+    Popover,
+    PopoverProps,
+    ProgressBar,
+    ProgressBarProps,
+    Radio,
+    RadioProps,
+    ResponsiveEmbed,
+    ResponsiveEmbedProps,
+    Row,
+    RowProps,
+    SafeAnchor,
+    SafeAnchorProps,
+    SplitButton,
+    SplitButtonProps,
+    SplitToggle,
+    SplitToggleProps,
+    Tab,
+    TabProps,
+    TabContainer,
+    TabContainerProps,
+    TabContent,
+    TabContentProps,
+    Table,
+    TableProps,
+    TabPane,
+    TabPaneProps,
+    Tabs,
+    TabsProps,
+    Thumbnail,
+    ThumbnailProps,
+    Tooltip,
+    TooltipProps,
+    Well,
+    WellProps,
+    utils
 }