anchor.diff:  
   typedef OnSelectHandler(String eventKey, [String href, dynamic unknown]);
   
  -typedef AccordionType({Map props, dynamic children});
  -
  -AccordionType Accordion =
  -    ({props, children}) => raw.Accordion_Raw(props, children);
  +// dynamic key, CLASSES bsClass, STYLES bsStyle, SIZES bsSize,
  +
  +/*
  + mixins: [BootstrapMixin],
  +
  +  propTypes: {
  +    : React.PropTypes.,
  +    : React.PropTypes.any,
  +    : React.PropTypes.,
  +    children: React.PropTypes.node,
  +    : React.PropTypes.any,
  +    : React.PropTypes.func
  +  },
  +*/
  +
  +typedef AccordionType({dynamic key, CLASSES bsClass, STYLES bsStyle, SIZES bsSize,
  +                      bool accordion, dynamic activeKey, String className, dynamic defaultActiveKey,
  +                      OnSelectHandler onSelect, Map props, dynamic children});
  +
  +AccordionType Accordion = ({key, bsClass, bsStyle, bsSize,
  +                           accordion: true, activeKey, className, defaultActiveKey,
  +                           onSelect, props, children}) => raw.Accordion_Raw(_mergeMaps({
  +  'key': key,
  +  'bsClass': CLASSES_MAP[bsClass],
  +  'bsStyle': STYLES_MAP[bsStyle],
  +  'bsSize': SIZES_MAP[bsSize],
  +  'accordion': accordion,
  +  'activeKey':activeKey,
  +  'className':className,
  +  'defaultActiveKey':defaultActiveKey,
  +  'onSelect':onSelect }, props), children);
  +
  +
  +/*
  +propTypes: {
  +    offset: React.PropTypes.number,
  +    offsetTop: React.PropTypes.number,
  +    offsetBottom: React.PropTypes.number
  +  },
  + */
   
   typedef AffixType({Map props, dynamic children});
   
   AffixType Affix = ({props, children}) => raw.Affix_Raw(props, children);
   
  +
  +/*
  +mixins: [BootstrapMixin],
  +
  +  propTypes: {
  +    onDismiss: React.PropTypes.func,
  +    dismissAfter: React.PropTypes.number,
  +    closeLabel: React.PropTypes.string
  +  },
  + */
  +
  +
   typedef AlertType({Map props, dynamic children});
   
   AlertType Alert = ({props, children}) => raw.Alert_Raw(props, children);
   
  +
  +/*
  +propTypes: {
  +    pullRight: React.PropTypes.bool
  +  },
  + */
  +
  +
   typedef BadgeType({Map props, dynamic children});
   
   BadgeType Badge = ({props, children}) => raw.Badge_Raw(props, children);
   
  +
   typedef ButtonType({dynamic key, CLASSES bsClass, STYLES bsStyle, SIZES bsSize, bool active,
  -    bool disabled, bool block, bool navItem, bool navDropdown,
  -    dynamic componentClass, String href, String target, Map style,
  -    OnClickHandler onClick, Map props, dynamic children});
  +                   bool disabled, bool block, bool navItem, bool navDropdown,
  +                   dynamic componentClass, String href, String target, Map style,
  +                   OnClickHandler onClick, Map props, dynamic children});
   
   ButtonType Button = ({key, bsClass: CLASSES.button, bsStyle: STYLES.defaultStyle,
  -    bsSize, active, disabled, block, navItem, navDropdown, componentClass, href,
  -    target, style, onClick, props, children}) => raw.Button_Raw(_mergeMaps({
  +                     bsSize, active, disabled, block, navItem, navDropdown, componentClass, href,
  +                     target, style, onClick, props, children}) => raw.Button_Raw(_mergeMaps({
     'key': key,
     'bsClass': CLASSES_MAP[bsClass],
     'bsStyle': STYLES_MAP[bsStyle],
  
positive.code:   'children': children
  }, props), children);
  
  typedef DropdownMenuType({Map props, dynamic children});
  
  DropdownMenuType DropdownMenu =
      ({props, children}) => raw.DropdownMenu_Raw(props, children);
  
  typedef DropdownStateMixinType({Map props, dynamic children});
  
  DropdownStateMixinType DropdownStateMixin =
      ({props, children}) => raw.DropdownStateMixin_Raw(props, children);
  
  typedef FadeMixinType({Map props, dynamic children});
  
  FadeMixinType FadeMixin =
      ({props, children}) => raw.FadeMixin_Raw(props, children);
  
  typedef FormControlsType({Map props, dynamic children});
  
  FormControlsType FormControls =
      ({props, children}) => raw.FormControls_Raw(props, children);
  
  typedef GlyphiconType(GLYPHS glyph, {CLASSES bsClass, STYLES bsStyle,
      SIZES bsSize, Map props, dynamic children});
  
  GlyphiconType Glyphicon = (glyph,
      {bsClass: 'glyphicon', bsStyle, bsSize, props, children}) => raw
      .Glyphicon_Raw(_mergeMaps({
    'glyph': GLYPHS_MAP[glyph],
    'bsClass': CLASSES_MAP[bsClass],
    'bsStyle': STYLES_MAP[bsStyle],
  
negative.code:   'target': target,
  }, props), children);
  
  
  /*
  const OverlayTrigger = React.createClass({
    mixins: [OverlayMixin],
  
    propTypes: {
      trigger: React.PropTypes.oneOfType([
        React.PropTypes.oneOf(['manual', 'click', 'hover', 'focus']),
        React.PropTypes.arrayOf(React.PropTypes.oneOf(['click', 'hover', 'focus']))
      ]),
      placement: React.PropTypes.oneOf(['top', 'right', 'bottom', 'left']),
      delay: React.PropTypes.number,
      delayShow: React.PropTypes.number,
      delayHide: React.PropTypes.number,
      defaultOverlayShown: React.PropTypes.bool,
      overlay: React.PropTypes.node.isRequired,
      onBlur: React.PropTypes.func,
      onClick: React.PropTypes.func,
      onFocus: React.PropTypes.func,
      onMouseEnter: React.PropTypes.func,
      onMouseLeave: React.PropTypes.func,
      containerPadding: React.PropTypes.number,
      rootClose: React.PropTypes.bool
    },
  
    getDefaultProps() {
      return {
        placement: 'right',
        trigger: ['hover', 'focus'],
        containerPadding: 0
      };
    },
   */
  
  typedef OverlayTriggerType({Map props, dynamic children});
  
  OverlayTriggerType OverlayTrigger =
      ({props, children}) => raw.OverlayTrigger_Raw(props, children);
  
  //typedef OverlayMixinType({Map props, dynamic children});
  //
  //OverlayMixinType OverlayMixin =
  //    ({props, children}) => raw.OverlayMixin_Raw(props, children);
  
  typedef PageHeaderType({Map props, dynamic children});
  
  PageHeaderType PageHeader =
      ({props, children}) => raw.PageHeader_Raw(props, children);
  
  
  /*
  const PageItem = React.createClass({
  
    propTypes: {
      href: React.PropTypes.string,
      target: React.PropTypes.string,
      title: React.PropTypes.string,
      disabled: React.PropTypes.bool,
      previous: React.PropTypes.bool,
      next: React.PropTypes.bool,
      onSelect: React.PropTypes.func,
      eventKey: React.PropTypes.any
    },
  
    getDefaultProps() {
      return {
        href: '#'
      };
    },
   */
  
  typedef PageItemType({Map props, dynamic children});
  
  PageItemType PageItem =
      ({props, children}) => raw.PageItem_Raw(props, children);
  
  /*
  const Pager = React.createClass({
  
    propTypes: {
      onSelect: React.PropTypes.func
    },
  
   */
  
  
  typedef PagerType({Map props, dynamic children});
  
  PagerType Pager = ({props, children}) => raw.Pager_Raw(props, children);
  
  
  /*
  const Panel = React.createClass({
    mixins: [BootstrapMixin, CollapsibleMixin],
  
    propTypes: {
      collapsible: React.PropTypes.bool,
      onSelect: React.PropTypes.func,
      header: React.PropTypes.node,
      id: React.PropTypes.string,
      footer: React.PropTypes.node,
      eventKey: React.PropTypes.any
    },
  
    getDefaultProps() {
      return {
        bsClass: 'panel',
        bsStyle: 'default'
      };
    },
   */
  
  typedef PanelType({Map props, dynamic children});
  
  PanelType Panel = ({props, children}) => raw.Panel_Raw(props, children);
  
  
  /*
  const PanelGroup = React.createClass({
    mixins: [BootstrapMixin],
  
    propTypes: {
      accordion: React.PropTypes.bool,
      activeKey: React.PropTypes.any,
      className: React.PropTypes.string,
      children: React.PropTypes.node,
      defaultActiveKey: React.PropTypes.any,
      onSelect: React.PropTypes.func
    },
  
    getDefaultProps() {
      return {
        bsClass: 'panel-group'
      };
    },
  
   */
  
  typedef PanelGroupType({Map props, dynamic children});
  
  PanelGroupType PanelGroup =
      ({props, children}) => raw.PanelGroup_Raw(props, children);
  
  
  /*
  const Popover = React.createClass({
    mixins: [BootstrapMixin, FadeMixin],
  
    propTypes: {
      placement: React.PropTypes.oneOf(['top', 'right', 'bottom', 'left']),
      positionLeft: React.PropTypes.number,
      positionTop: React.PropTypes.number,
      arrowOffsetLeft: React.PropTypes.oneOfType([
        React.PropTypes.number, React.PropTypes.string
      ]),
      arrowOffsetTop: React.PropTypes.oneOfType([
        React.PropTypes.number, React.PropTypes.string
      ]),
      title: React.PropTypes.node,
      animation: React.PropTypes.bool
    },
  
    getDefaultProps() {
      return {
        placement: 'right',
        animation: true
      };
    },
   */
  
  
  
  typedef PopoverType({Map props, dynamic children});
  
  PopoverType Popover = ({props, children}) => raw.Popover_Raw(props, children);
  
  
  /*
  const ProgressBar = React.createClass({
    propTypes: {
      min: PropTypes.number,
      now: PropTypes.number,
      max: PropTypes.number,
      label: PropTypes.node,
      srOnly: PropTypes.bool,
      striped: PropTypes.bool,
      active: PropTypes.bool,
      children: onlyProgressBar,
      className: React.PropTypes.string,
      interpolateClass: PropTypes.node,
      isChild: PropTypes.bool
    },
  
    mixins: [BootstrapMixin],
  
    getDefaultProps() {
      return {
        bsClass: 'progress-bar',
        min: 0,
        max: 100
      };
    },
   */
  
  
  typedef ProgressBarType({Map props, dynamic children});
  
  ProgressBarType ProgressBar =
      ({props, children}) => raw.ProgressBar_Raw(props, children);
  
  
  typedef RowType({dynamic componentClass, Map props, dynamic children});
  
  RowType Row = ({componentClass: 'div', props, children}) => raw.Row_Raw(
      _mergeMaps({'componentClass': componentClass}, props), children);
  
  
  
  //typedef SafeAnchorType({Map props, dynamic children});
  //
  //SafeAnchorType SafeAnchor =
  //    ({props, children}) => raw.SafeAnchor_Raw(props, children);
  
  /*
  const SplitButton = React.createClass({
    mixins: [BootstrapMixin, DropdownStateMixin],
  
    propTypes: {
      pullRight:     React.PropTypes.bool,
      title:         React.PropTypes.node,
      href:          React.PropTypes.string,
      id:            React.PropTypes.string,
      target:        React.PropTypes.string,
      dropdownTitle: React.PropTypes.node,
      dropup:        React.PropTypes.bool,
      onClick:       React.PropTypes.func,
      onSelect:      React.PropTypes.func,
      disabled:      React.PropTypes.bool,
      className:     React.PropTypes.string,
      children:      React.PropTypes.node
    },
  
    getDefaultProps() {
      return {
        dropdownTitle: 'Toggle dropdown'
      };
    },
   */
  
  typedef SplitButtonType({Map props, dynamic children});
  
  SplitButtonType SplitButton =
      ({props, children}) => raw.SplitButton_Raw(props, children);
  
  /*
  const SubNav = React.createClass({
    mixins: [BootstrapMixin],
  
    propTypes: {
      onSelect: React.PropTypes.func,
      active: React.PropTypes.bool,
      activeHref: React.PropTypes.string,
      activeKey: React.PropTypes.any,
      disabled: React.PropTypes.bool,
      eventKey: React.PropTypes.any,
      href: React.PropTypes.string,
      title: React.PropTypes.string,
      text: React.PropTypes.node,
      target: React.PropTypes.string
    },
  
    getDefaultProps() {
      return {
        bsClass: 'nav'
      };
    }, */
  
  typedef SubNavType({Map props, dynamic children});
  
  SubNavType SubNav = ({props, children}) => raw.SubNav_Raw(props, children);
  
  /*
  const TabPane = React.createClass({
    propTypes: {
      active:          React.PropTypes.bool,
      animation:       React.PropTypes.bool,
      onAnimateOutEnd: React.PropTypes.func,
      disabled:        React.PropTypes.bool
    },
  
    getDefaultProps() {
      return {
        animation: true
      };
    },
   */
  
  
  typedef TabPaneType({Map props, dynamic children});
  
  TabPaneType TabPane = ({props, children}) => raw.TabPane_Raw(props, children);
  
  /*
  const TabbedArea = React.createClass({
    mixins: [BootstrapMixin],
  
    propTypes: {
      activeKey: React.PropTypes.any,
      defaultActiveKey: React.PropTypes.any,
      bsStyle: React.PropTypes.oneOf(['tabs', 'pills']),
      animation: React.PropTypes.bool,
      id: React.PropTypes.string,
      onSelect: React.PropTypes.func
    },
  
    getDefaultProps() {
      return {
        bsStyle: 'tabs',
        animation: true
      };
    },
  
   */
  
  
  typedef TabbedAreaType({Map props, dynamic children});
  
  TabbedAreaType TabbedArea =
      ({props, children}) => raw.TabbedArea_Raw(props, children);
  
  /*
  const Table = React.createClass({
    propTypes: {
      striped: React.PropTypes.bool,
      bordered: React.PropTypes.bool,
      condensed: React.PropTypes.bool,
      hover: React.PropTypes.bool,
      responsive: React.PropTypes.bool
    },
  */
  
  typedef TableType({Map props, dynamic children});
  
  TableType Table = ({props, children}) => raw.Table_Raw(props, children);
  
  
  /*
  const Thumbnail = React.createClass({
    mixins: [BootstrapMixin],
  
    propTypes: {
      alt: React.PropTypes.string,
      href: React.PropTypes.string,
      src: React.PropTypes.string
    },
  
    getDefaultProps() {
      return {
        bsClass: 'thumbnail'
      };
    },
  
  */
  
  typedef ThumbnailType({Map props, dynamic children});
  
  ThumbnailType Thumbnail =
      ({props, children}) => raw.Thumbnail_Raw(props, children);
  
  
  /*
  const Tooltip = React.createClass({
    mixins: [BootstrapMixin, FadeMixin],
  
    propTypes: {
      placement: React.PropTypes.oneOf(['top', 'right', 'bottom', 'left']),
      positionLeft: React.PropTypes.number,
      positionTop: React.PropTypes.number,
      arrowOffsetLeft: React.PropTypes.oneOfType([
        React.PropTypes.number, React.PropTypes.string
      ]),
      arrowOffsetTop: React.PropTypes.oneOfType([
        React.PropTypes.number, React.PropTypes.string
      ]),
      animation: React.PropTypes.bool
    },
  
    getDefaultProps() {
      return {
        placement: 'right',
        animation: true
      };
    },
  
  */
  
  typedef TooltipType({Map props, dynamic children});
  
  TooltipType Tooltip = ({props, children}) => raw.Tooltip_Raw(props, children);
  
  
  /*
  const Well = React.createClass({
    mixins: [BootstrapMixin],
  
    getDefaultProps() {
      return {
        bsClass: 'well'
      };
    },
   */
  
  typedef WellType({Map props, dynamic children});
  
  WellType Well = ({props, children}) => raw.Well_Raw(props, children);
  