New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@types/react-bootstrap

Package Overview
Dependencies
Maintainers
1
Versions
85
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@types/react-bootstrap - npm Package Compare versions

Comparing version 0.31.1 to 0.31.2

96

react-bootstrap/index.d.ts

@@ -11,2 +11,3 @@ // Type definitions for react-bootstrap 0.31

// Vito Samson <https://github.com/vitosamson>
// Karol Janyst <https://github.com/LKay>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

@@ -17,2 +18,5 @@ // TypeScript Version: 2.3

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

@@ -39,92 +43,2 @@

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,
ToggleButton,
ToggleButtonGroup,
Tooltip,
Well,
utils,
} from './lib';
export * from './lib';

26

react-bootstrap/lib/Accordion.d.ts
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
}

21

react-bootstrap/lib/Alert.d.ts
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;

14

react-bootstrap/lib/Badge.d.ts
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;

14

react-bootstrap/lib/Breadcrumb.d.ts
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;

18

react-bootstrap/lib/BreadcrumbItem.d.ts
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;

24

react-bootstrap/lib/Button.d.ts
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;

20

react-bootstrap/lib/ButtonGroup.d.ts
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;

20

react-bootstrap/lib/ButtonToolbar.d.ts
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;

49

react-bootstrap/lib/Carousel.d.ts
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 type CarouselProps = 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;

12

react-bootstrap/lib/CarouselCaption.d.ts
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;

23

react-bootstrap/lib/CarouselItem.d.ts
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;

20

react-bootstrap/lib/Checkbox.d.ts
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;

20

react-bootstrap/lib/Clearfix.d.ts
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;

52

react-bootstrap/lib/Col.d.ts
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;

22

react-bootstrap/lib/Collapse.d.ts
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;

16

react-bootstrap/lib/ControlLabel.d.ts
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;

38

react-bootstrap/lib/Dropdown.d.ts

@@ -6,24 +6,26 @@ import * as React from 'react';

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

25

react-bootstrap/lib/DropdownButton.d.ts

@@ -5,15 +5,16 @@ import * as React from 'react';

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;
}
interface DropdownButtonBaseProps extends DropdownBaseProps {
block?: boolean;
bsSize?: Sizes;
bsStyle?: string;
navItem?: boolean;
noCaret?: boolean;
pullRight?: boolean;
export type DropdownButtonProps = DropdownButtonBaseProps & React.HTMLProps<DropdownButton>;
}
type DropdownButtonProps = DropdownButtonBaseProps & React.HTMLProps<DropdownButton>;
declare class DropdownButton extends React.Component<DropdownButton.DropdownButtonProps> { }
export = DropdownButton;

20

react-bootstrap/lib/DropdownMenu.d.ts
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;

23

react-bootstrap/lib/DropdownToggle.d.ts
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;

18

react-bootstrap/lib/Fade.d.ts
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;

18

react-bootstrap/lib/Form.d.ts
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;

26

react-bootstrap/lib/FormControl.d.ts

@@ -6,16 +6,16 @@ import * as React from 'react';

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;

10

react-bootstrap/lib/FormControlFeedback.d.ts
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;

14

react-bootstrap/lib/FormControlStatic.d.ts
import * as React from 'react';
declare class FormControlStatic extends React.Component<FormControlStaticProps> { }
declare namespace FormControlStatic { }
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
interface FormControlStaticProps extends React.HTMLProps<FormControlStatic> {
bsClass?: string;
componentClass?: React.ReactType;
}

18

react-bootstrap/lib/FormGroup.d.ts
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;

14

react-bootstrap/lib/Glyphicon.d.ts
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;

16

react-bootstrap/lib/Grid.d.ts
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;

12

react-bootstrap/lib/HelpBlock.d.ts
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;

18

react-bootstrap/lib/Image.d.ts
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;

530

react-bootstrap/lib/index.d.ts

@@ -1,89 +0,177 @@

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 ToggleButton from './ToggleButton'
import * as ToggleButtonGroup from './ToggleButtonGroup'
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 ToggleButton = require('./ToggleButton');
import { ToggleButtonProps } from './ToggleButton';
import ToggleButtonGroup = require('./ToggleButtonGroup');
import { ToggleButtonGroupProps } from './ToggleButtonGroup';
import Tooltip = require('./Tooltip');
import { TooltipProps } from './Tooltip';
import Well = require('./Well');
import { WellProps } from './Well';

@@ -93,91 +181,179 @@ 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,
ToggleButton,
ToggleButtonGroup,
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,
ToggleButton,
ToggleButtonProps,
ToggleButtonGroup,
ToggleButtonGroupProps,
Tooltip,
TooltipProps,
Well,
WellProps,
utils
}

18

react-bootstrap/lib/InputGroup.d.ts

@@ -6,12 +6,12 @@ import * as React from 'react';

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;

10

react-bootstrap/lib/InputGroupAddon.d.ts
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;

10

react-bootstrap/lib/InputGroupButton.d.ts
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;

12

react-bootstrap/lib/Jumbotron.d.ts
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;

14

react-bootstrap/lib/Label.d.ts
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;

16

react-bootstrap/lib/ListGroup.d.ts
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;

22

react-bootstrap/lib/ListGroupItem.d.ts
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;

24

react-bootstrap/lib/Media.d.ts

@@ -9,15 +9,15 @@ import * as React from 'react';

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;

12

react-bootstrap/lib/MediaBody.d.ts
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;

12

react-bootstrap/lib/MediaHeading.d.ts
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;

12

react-bootstrap/lib/MediaLeft.d.ts
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;

10

react-bootstrap/lib/MediaList.d.ts
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;

12

react-bootstrap/lib/MediaListItem.d.ts
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;

12

react-bootstrap/lib/MediaRight.d.ts
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;

30

react-bootstrap/lib/MenuItem.d.ts
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;

66

react-bootstrap/lib/Modal.d.ts

@@ -9,36 +9,36 @@ import * as React from 'react';

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;

13

react-bootstrap/lib/ModalBody.d.ts
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;

26

react-bootstrap/lib/ModalDialog.d.ts
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;

13

react-bootstrap/lib/ModalFooter.d.ts
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;

17

react-bootstrap/lib/ModalHeader.d.ts
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;

13

react-bootstrap/lib/ModalTitle.d.ts
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;

41

react-bootstrap/lib/Nav.d.ts
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;

58

react-bootstrap/lib/Navbar.d.ts

@@ -8,31 +8,31 @@ import * as React from 'react';

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;

@@ -43,5 +43,5 @@ /**

interface NavbarLinkProps extends React.Props<NavbarLink> {
interface NavbarLinkProps extends React.HTMLProps<NavbarLink> {
href: string;
onClick?: React.MouseEventHandler<HTMLAnchorElement>;
onClick?: React.MouseEventHandler<any>;
}

@@ -48,0 +48,0 @@ declare class NavbarLink extends React.Component<NavbarLinkProps> { }

10

react-bootstrap/lib/NavbarBrand.d.ts
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;

7

react-bootstrap/lib/NavbarCollapse.d.ts
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> { }

9

react-bootstrap/lib/NavbarHeader.d.ts
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;

12

react-bootstrap/lib/NavbarToggle.d.ts
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;

18

react-bootstrap/lib/NavDropdown.d.ts
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;

46

react-bootstrap/lib/NavItem.d.ts
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;

30

react-bootstrap/lib/Overlay.d.ts
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;

48

react-bootstrap/lib/OverlayTrigger.d.ts
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;

9

react-bootstrap/lib/PageHeader.d.ts
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;

9

react-bootstrap/lib/PageItem.d.ts
/** @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;

14

react-bootstrap/lib/Pager.d.ts

@@ -5,10 +5,10 @@ import * as React from 'react';

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;

22

react-bootstrap/lib/PagerItem.d.ts
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;

36

react-bootstrap/lib/Pagination.d.ts
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;

24

react-bootstrap/lib/PaginationButton.d.ts
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;

30

react-bootstrap/lib/Panel.d.ts
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;

22

react-bootstrap/lib/PanelGroup.d.ts
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;

26

react-bootstrap/lib/Popover.d.ts
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;

30

react-bootstrap/lib/ProgressBar.d.ts
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;

19

react-bootstrap/lib/Radio.d.ts
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;

16

react-bootstrap/lib/ResponsiveEmbed.d.ts
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;

12

react-bootstrap/lib/Row.d.ts
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;

20

react-bootstrap/lib/SafeAnchor.d.ts
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;

20

react-bootstrap/lib/SplitButton.d.ts
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;

9

react-bootstrap/lib/SplitToggle.d.ts
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;

28

react-bootstrap/lib/Tab.d.ts

@@ -7,17 +7,17 @@ import * as React from 'react';

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;

16

react-bootstrap/lib/TabContainer.d.ts
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;

18

react-bootstrap/lib/TabContent.d.ts
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;

24

react-bootstrap/lib/Table.d.ts
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;

20

react-bootstrap/lib/TabPane.d.ts
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;

30

react-bootstrap/lib/Tabs.d.ts
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;

14

react-bootstrap/lib/Thumbnail.d.ts
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;

16

react-bootstrap/lib/ToggleButton.d.ts
import * as React from 'react';
declare class ToggleButton extends React.Component<ToggleButtonProps> { }
declare namespace ToggleButton { }
export = ToggleButton
interface ToggleButtonProps extends React.HTMLProps<ToggleButton> {
checked?: boolean;
name?: string;
value: number|string;
declare namespace ToggleButton {
export interface ToggleButtonProps extends React.HTMLProps<ToggleButton> {
checked?: boolean;
name?: string;
value: number|string;
}
}
declare class ToggleButton extends React.Component<ToggleButton.ToggleButtonProps> { }
export = ToggleButton;

48

react-bootstrap/lib/ToggleButtonGroup.d.ts
import * as React from 'react';
import { Omit } from "../index";
declare class ToggleButtonGroup extends React.Component<ToggleButtonGroupProps> { }
declare namespace ToggleButtonGroup { }
export = ToggleButtonGroup
declare namespace ToggleButtonGroup {
interface BaseProps {
/**
* You'll usually want to use string|number|string[]|number[] here,
* but you can technically use any|any[].
*/
defaultValue?: any;
/**
* You'll usually want to use string|number|string[]|number[] here,
* but you can technically use any|any[].
*/
value?: any;
}
interface ToggleButtonGroupProps extends React.HTMLProps<ToggleButtonGroup> {
/** Required if `type` is set to "radio" */
name?: string;
type: "radio" | "checkbox";
/**
* You'll usually want to use string|number|string[]|number[] here,
* but you can technically use any|any[].
*/
defaultValue?: any;
/**
* You'll usually want to use string|number|string[]|number[] here,
* but you can technically use any|any[].
*/
value?: any;
interface RadioProps {
/** Required if `type` is set to "radio" */
name: string;
type: "radio";
}
interface CheckboxProps {
name?: string;
type: "checkbox";
}
export type ToggleButtonGroupProps = BaseProps
& (RadioProps | CheckboxProps)
& Omit<React.HTMLProps<ToggleButtonGroup>, "defaultValue" | "type" | "value">;
}
declare class ToggleButtonGroup extends React.Component<ToggleButtonGroup.ToggleButtonGroupProps> { }
export = ToggleButtonGroup;

26

react-bootstrap/lib/Tooltip.d.ts
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;

0

react-bootstrap/lib/utils/bootstrapUtils.d.ts

@@ -0,0 +0,0 @@ interface BSProps {

0

react-bootstrap/lib/utils/capitalize.d.ts
export default function capitalize(string: string): string;

0

react-bootstrap/lib/utils/createChainedFunction.d.ts
export default function createChainedFunction(...funcs: Function[]): Function;

0

react-bootstrap/lib/utils/deprecationWarning.d.ts
export default function deprecationWarning(oldname: any, newname: string, link?: string): void;
export function wrapper(Component: any, ...args: any[]): any;
export function _resetWarned(): void;

0

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

@@ -0,0 +0,0 @@ import * as bootstrapUtils from './bootstrapUtils';

0

react-bootstrap/lib/utils/PropTypes.d.ts
export function requiredRoles(...roles: any[]): any;
export function exclusiveRoles(...roles: any[]): any;

0

react-bootstrap/lib/utils/splitComponentProps.d.ts
export default function splitComponentProps(props: any, Component: any): [any, any];

0

react-bootstrap/lib/utils/StyleConfig.d.ts

@@ -0,0 +0,0 @@ export const Size: {

14

react-bootstrap/lib/Well.d.ts
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;

9

react-bootstrap/package.json
{
"name": "@types/react-bootstrap",
"version": "0.31.1",
"version": "0.31.2",
"description": "TypeScript definitions for react-bootstrap",

@@ -46,2 +46,7 @@ "license": "MIT",

"githubUsername": "vitosamson"
},
{
"name": "Karol Janyst",
"url": "https://github.com/LKay",
"githubUsername": "LKay"
}

@@ -58,4 +63,4 @@ ],

},
"typesPublisherContentHash": "0a46ffbb4768ef1032c688df11275735bd2d995cdb2a20cbc939e9e1a1ba08f1",
"typesPublisherContentHash": "2cba278cd16d757bafed1ccf35727875fa10368c517f499e5f8cb3e25d4709c2",
"typeScriptVersion": "2.3"
}

4

react-bootstrap/README.md

@@ -11,3 +11,3 @@ # Installation

Additional Details
* Last updated: Wed, 06 Sep 2017 14:55:01 GMT
* Last updated: Tue, 12 Sep 2017 00:45:15 GMT
* Dependencies: react

@@ -17,2 +17,2 @@ * Global values: none

# Credits
These definitions were written by Walker Burgin <https://github.com/walkerburgin>, Vincent Siao <https://github.com/vsiao>, Danilo Barros <https://github.com/danilojrr>, Batbold Gansukh <https://github.com/Batbold-Gansukh>, Raymond May Jr. <https://github.com/octatone>, Cheng Sieu Ly <https://github.com/chengsieuly>, Kat Busch <https://github.com/katbusch>, Vito Samson <https://github.com/vitosamson>.
These definitions were written by Walker Burgin <https://github.com/walkerburgin>, Vincent Siao <https://github.com/vsiao>, Danilo Barros <https://github.com/danilojrr>, Batbold Gansukh <https://github.com/Batbold-Gansukh>, Raymond May Jr. <https://github.com/octatone>, 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>.
react-bootstrap/LICENSE

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc