anchor.diff:    'onClick': onClick
   }, props), children);
   
  +
  +/*
  +const ButtonGroup = React.createClass({
  +  mixins: [BootstrapMixin],
  +
  +  propTypes: {
  +    vertical:  React.PropTypes.bool,
  +    justified: React.PropTypes.bool,
  +    /**
  +     * Display block buttons, only useful when used with the "vertical" prop.
  +     * @type {bool}
  +     */
  +    block: CustomPropTypes.all([
  +      React.PropTypes.bool,
  +      function(props, propName, componentName) {
  +        if (props.block && !props.vertical) {
  +          return new Error('The block property requires the vertical property to be set to have any effect');
  +        }
  +      }
  +    ])
  +  },
  + */
  +
   typedef ButtonGroupType({Map props, dynamic children});
   
   ButtonGroupType ButtonGroup =
       ({props, children}) => raw.ButtonGroup_Raw(props, children);
   
  +
  +/*
  +ButtonInput.types = ['button', 'reset', 'submit'];
  +
  +ButtonInput.propTypes = {
  +  type: React.PropTypes.oneOf(ButtonInput.types),
  +  bsStyle(props) {
  +    //defer to Button propTypes of bsStyle
  +    return null;
  +  },
  +  children: childrenValueValidation,
  +  value: childrenValueValidation
  +};
  +
  +InputBase.propTypes = {
  +  type: React.PropTypes.string,
  +  label: React.PropTypes.node,
  +  help: React.PropTypes.node,
  +  addonBefore: React.PropTypes.node,
  +  addonAfter: React.PropTypes.node,
  +  buttonBefore: React.PropTypes.node,
  +  buttonAfter: React.PropTypes.node,
  +  bsSize: React.PropTypes.oneOf(['small', 'medium', 'large']),
  +  bsStyle: React.PropTypes.oneOf(['success', 'warning', 'error']),
  +  hasFeedback: React.PropTypes.bool,
  +  id: React.PropTypes.string,
  +  groupClassName: React.PropTypes.string,
  +  wrapperClassName: React.PropTypes.string,
  +  labelClassName: React.PropTypes.string,
  +  multiple: React.PropTypes.bool,
  +  disabled: React.PropTypes.bool,
  +  value: React.PropTypes.any
  +};
  + */
  +
   typedef ButtonInputType({Map props, dynamic children});
   
   ButtonInputType ButtonInput =
       ({props, children}) => raw.ButtonInput_Raw(props, children);
   
  +
  +
   typedef ButtonToolbarType({CLASSES bsClass, STYLES bsStyle, SIZES bsSize,
  -    Map props, dynamic children});
  +                          Map props, dynamic children});
   
   ButtonToolbarType ButtonToolbar = ({bsClass: CLASSES.button_toolbar,
  -    bsStyle, bsSize, props, children}) => raw
  -    .ButtonToolbar_Raw(_mergeMaps({
  +                                   bsStyle, bsSize, props, children}) => raw
  +.ButtonToolbar_Raw(_mergeMaps({
     'bsClass': CLASSES_MAP[bsClass],
     'bsStyle': STYLES_MAP[bsStyle],
     'bsSize': SIZES_MAP[bsSize],
   }, props), children);
   
  +
  +/*
  +const CollapsibleNav = React.createClass({
  +  mixins: [BootstrapMixin, CollapsibleMixin],
  +
  +  propTypes: {
  +    onSelect: React.PropTypes.func,
  +    activeHref: React.PropTypes.string,
  +    activeKey: React.PropTypes.any,
  +    collapsible: React.PropTypes.bool,
  +    expanded: React.PropTypes.bool,
  +    eventKey: React.PropTypes.any
  +  },
  +
  +  const CollapsibleMixin = {
  +
  +  propTypes: {
  +    defaultExpanded: React.PropTypes.bool,
  +    expanded: React.PropTypes.bool
  +  },
  + */
  +
   typedef CollapsibleNavType({Map props, dynamic children});
   
   CollapsibleNavType CollapsibleNav =
       ({props, children}) => raw.CollapsibleNav_Raw(props, children);
   
  +
  +/*
  +const Carousel = React.createClass({
  +  mixins: [BootstrapMixin],
  +
  +  propTypes: {
  +    slide: React.PropTypes.bool,
  +    indicators: React.PropTypes.bool,
  +    interval: React.PropTypes.number,
  +    controls: React.PropTypes.bool,
  +    pauseOnHover: React.PropTypes.bool,
  +    wrap: React.PropTypes.bool,
  +    onSelect: React.PropTypes.func,
  +    onSlideEnd: React.PropTypes.func,
  +    activeIndex: React.PropTypes.number,
  +    defaultActiveIndex: React.PropTypes.number,
  +    direction: React.PropTypes.oneOf(['prev', 'next']),
  +    prevIcon: React.PropTypes.node,
  +    nextIcon: React.PropTypes.node
  +  },
  +
  +  getDefaultProps() {
  +    return {
  +      slide: true,
  +      interval: 5000,
  +      pauseOnHover: true,
  +      wrap: true,
  +      indicators: true,
  +      controls: true,
  +      prevIcon: <Glyphicon glyph="chevron-left" />,
  +      nextIcon: <Glyphicon glyph="chevron-right" />
  +    };
  +  },
  + */
  +
   typedef CarouselType({Map props, dynamic children});
   
   CarouselType Carousel =
       ({props, children}) => raw.Carousel_Raw(props, children);
   
  +
  +/*
  +const CarouselItem = React.createClass({
  +  propTypes: {
  +    direction: React.PropTypes.oneOf(['prev', 'next']),
  +    onAnimateOutEnd: React.PropTypes.func,
  +    active: React.PropTypes.bool,
  +    animateIn: React.PropTypes.bool,
  +    animateOut: React.PropTypes.bool,
  +    caption: React.PropTypes.node,
  +    index: React.PropTypes.number
  +  },
  +
  +  getDefaultProps() {
  +    return {
  +      animation: true
  +    };
  +  },
  + */
  +
  +
   typedef CarouselItemType({Map props, dynamic children});
   
   CarouselItemType CarouselItem =
       ({props, children}) => raw.CarouselItem_Raw(props, children);
   
   typedef ColType({dynamic key, int xs, int sm, int md, int lg, int xsOffset, int smOffset,
  -    int mdOffset, int lgOffset, int xsPush, int smPush, int mdPush, int lgPush,
  -    int xsPull, int smPull, int mdPull, int lgPull, dynamic componentClass,
  -    Map props, dynamic children});
  +                int mdOffset, int lgOffset, int xsPush, int smPush, int mdPush, int lgPush,
  +                int xsPull, int smPull, int mdPull, int lgPull, dynamic componentClass,
  +                Map props, dynamic children});
   
   ColType Col = ({key, xs, sm, md, lg, xsOffset, smOffset, mdOffset, lgOffset, xsPush,
  -    smPush, mdPush, lgPush, xsPull, smPull, mdPull, lgPull,
  -    componentClass: 'div', props, children}) => raw.Col_Raw(_mergeMaps({
  +               smPush, mdPush, lgPush, xsPull, smPull, mdPull, lgPull,
  +               componentClass: 'div', props, children}) => raw.Col_Raw(_mergeMaps({
     'key': key,
     'xs': xs,
     'sm': sm,
  
positive.code:     {bool fluid, dynamic componentClass, Map props, dynamic children});
  
  GridType Grid = ({fluid, componentClass: 'div', props, children}) => raw
      .Grid_Raw(
          _mergeMaps({'fluid': fluid, 'componentClass': componentClass}, props),
          children);
  
  typedef InputType({Map props, dynamic children});
  
  InputType Input = ({props, children}) => raw.Input_Raw(props, children);
  
  typedef InterpolateType({Map props, dynamic children});
  
  InterpolateType Interpolate =
      ({props, children}) => raw.Interpolate_Raw(props, children);
  
  typedef JumbotronType({Map props, dynamic children});
  
  JumbotronType Jumbotron =
      ({props, children}) => raw.Jumbotron_Raw(props, children);
  
  typedef LabelType({Map props, dynamic children});
  
  LabelType Label = ({props, children}) => raw.Label_Raw(props, children);
  
  typedef ListGroupType({Map props, dynamic children});
  
  ListGroupType ListGroup =
      ({props, children}) => raw.ListGroup_Raw(props, children);
  
  typedef ListGroupItemType({Map props, dynamic children});
  
  ListGroupItemType ListGroupItem =
      ({props, children}) => raw.ListGroupItem_Raw(props, children);
  
  typedef MenuItemType({dynamic key, bool header, bool divider, String href, String title,
      String target, OnSelectHandler onSelect, dynamic eventKey, bool active,
      bool disabled, Map props, dynamic children});
  
  MenuItemType MenuItem = ({key, header, divider, href: '#', title, target, onSelect,
      eventKey, active: false, disabled, props, children}) => raw.MenuItem_Raw(
          _mergeMaps({
    'key': key,
    'header': header,
    'divider': divider,
    'href': href,
    'title': title,
    'target': target,
    'onSelect': onSelect,
    'eventKey': eventKey,
    'active': active,
    'disabled': disabled,
  }, props), children);
  
  typedef ModalType({Map props, dynamic children});
  
  ModalType Modal = ({props, children}) => raw.Modal_Raw(props, children);
  
  typedef NavType({dynamic key, CLASSES bsClass, NAV_STYLES bsStyle, SIZES bsSize,
      String activeHref, dynamic activeKey, bool stacked, bool justified,
      OnSelectHandler onSelect, bool collapsible, bool expanded, bool navbar,
      dynamic eventKey, bool pullRight, bool right, bool defaultExpanded,
      Map props, dynamic children});
  
  NavType Nav = ({key, bsClass: CLASSES.nav, bsStyle, bsSize, activeHref,
      activeKey, stacked, justified, onSelect, collapsible, expanded, navbar,
      eventKey, pullRight, right, defaultExpanded, props, children}) => raw
      .Nav_Raw(_mergeMaps({
    'key': key,
    'bsClass': CLASSES_MAP[bsClass],
    'bsStyle': STYLES_MAP[bsStyle],
  
negative.code: }, props), children);
  
  typedef NavItemType({dynamic key, CLASSES bsClass, NAV_STYLES bsStyle,
                      SIZES bsSize, OnSelectHandler onSelect, bool active, bool disabled,
                      String href, dynamic title, dynamic eventKey, String target, Map props,
                      dynamic children});
  
  NavItemType NavItem = ({key, bsClass, bsStyle, bsSize, onSelect, active,
                         disabled, href, title, eventKey, target, props, children}) => raw
  .NavItem_Raw(_mergeMaps({
    'key': key,
    'bsClass': CLASSES_MAP[bsClass],
    'bsStyle': STYLES_MAP[bsStyle],
  