materialuiupgraded/examples/create-react-app-with-flow/flow-typed/npm/material-ui_v1.x.x.js

Material-UI's workspace package

// flow-typed signature: c30f67b0b88c8cea0ad8d876abb8d42e
// flow-typed version: f6dc3bf38d/material-ui_v1.x.x/flow_>=v0.58.x

declare module "material-ui/AppBar/AppBar" {
  declare type Color = "inherit" | "primary" | "secondary" | "default";
  declare type Position = "fixed" | "absolute" | "sticky" | "static";

  declare module.exports: React$ComponentType<{
    children?: React$Node,
    className?: string,
    classes?: Object,
    color?: Color,
    position?: Position
  }>;
}

declare module "material-ui/AppBar" {
  declare module.exports: $Exports<"material-ui/AppBar/AppBar">;
}

declare module "material-ui/Avatar/Avatar" {
  declare module.exports: React$ComponentType<{
    alt?: string,
    children?: string | React$Element<any>,
    childrenClassName?: string,
    className?: string,
    classes?: Object,
    component?: React$ElementType,
    imgProps?: Object,
    sizes?: string,
    src?: string,
    srcSet?: string
  }>;
}

declare module "material-ui/Avatar" {
  declare module.exports: $Exports<"material-ui/Avatar/Avatar">;
}

declare module "material-ui/Badge/Badge" {
  declare type Color = "default" | "primary" | "accent";

  declare module.exports: React$ComponentType<{
    badgeContent: React$Node,
    children: React$Node,
    className?: string,
    classes?: Object,
    color?: Color
  }>;
}

declare module "material-ui/Badge" {
  declare module.exports: $Exports<"material-ui/Badge/Badge">;
}

declare module "material-ui/BottomNavigation/BottomNavigation" {
  declare module.exports: React$ComponentType<{
    children: React$Node,
    className?: string,
    classes?: Object,
    onChange?: Function,
    showLabels?: boolean,
    value: any
  }>;
}

declare module "material-ui/BottomNavigation/BottomNavigationAction" {
  declare module.exports: React$ComponentType<{
    className?: string,
    classes?: Object,
    icon?: string | React$Element<any>,
    label?: React$Node,
    onChange?: Function,
    onClick?: Function,
    selected?: boolean,
    showLabel?: boolean,
    value?: any
  }>;
}

declare module "material-ui/BottomNavigation" {
  declare export var BottomNavigationAction: $Exports<
    "material-ui/BottomNavigation/BottomNavigationAction"
  >;
  declare export default $Exports<
    "material-ui/BottomNavigation/BottomNavigation"
  >;
}

declare module "material-ui/Button/Button" {
  declare type Color = "default" | "inherit" | "primary" | "secondary";

  declare module.exports: React$ComponentType<{
    children: React$Node,
    className?: string,
    classes?: Object,
    color?: Color,
    component?: React$ElementType,
    dense?: boolean,
    disableFocusRipple?: boolean,
    disabled?: boolean,
    disableRipple?: boolean,
    fab?: boolean,
    href?: string,
    raised?: boolean,
    type?: string
  }>;
}

declare module "material-ui/Button" {
  declare module.exports: $Exports<"material-ui/Button/Button">;
}

declare module "material-ui/ButtonBase/ButtonBase" {
  declare module.exports: React$ComponentType<{
    centerRipple?: boolean,
    children?: React$Node,
    className?: string,
    classes?: Object,
    component?: React$ElementType,
    disableRipple?: boolean,
    disabled?: boolean,
    focusRipple?: boolean,
    keyboardFocusedClassName?: string,
    onBlur?: Function,
    onClick?: Function,
    onFocus?: Function,
    onKeyDown?: Function,
    onKeyUp?: Function,
    onKeyboardFocus?: (event: SyntheticEvent<>) => void,
    onMouseDown?: Function,
    onMouseLeave?: Function,
    onMouseUp?: Function,
    onTouchEnd?: Function,
    onTouchMove?: Function,
    onTouchStart?: Function,
    role?: string,
    rootRef?: Function,
    tabIndex?: number | string,
    type?: string
  }>;
}

declare module "material-ui/ButtonBase/createRippleHandler" {
  declare function handleEvent(event: SyntheticUIEvent<>): void;
  declare module.exports: (
    instance: Object,
    eventName: string,
    action: string,
    cb: ?Function
  ) => handleEvent;
}

declare module "material-ui/ButtonBase" {
  declare module.exports: $Exports<"material-ui/ButtonBase/ButtonBase">;
}

declare module "material-ui/ButtonBase/Ripple" {
  declare module.exports: React$ComponentType<{
    className?: string,
    classes?: Object,
    pulsate?: boolean,
    rippleSize: number,
    rippleX: number,
    rippleY: number
  }>;
}

declare module "material-ui/ButtonBase/TouchRipple" {
  declare module.exports: React$ComponentType<{
    center?: boolean,
    className?: string,
    classes?: Object
  }>;
}

declare module "material-ui/Card/Card" {
  declare module.exports: React$ComponentType<{
    className?: string,
    raised?: boolean
  }>;
}

declare module "material-ui/Card/CardActions" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    className?: string,
    classes?: Object,
    disableActionSpacing?: boolean
  }>;
}

declare module "material-ui/Card/CardContent" {
  declare module.exports: React$ComponentType<{
    className?: string,
    classes?: Object
  }>;
}

declare module "material-ui/Card/CardHeader" {
  declare module.exports: React$ComponentType<{
    action?: React$Node,
    avatar?: React$Node,
    className?: string,
    classes?: Object,
    subheader?: React$Node,
    title?: React$Node
  }>;
}

declare module "material-ui/Card/CardMedia" {
  declare module.exports: React$ComponentType<{
    className?: string,
    classes?: Object,
    component?: React$ElementType,
    image?: string,
    src?: string,
    style?: Object
  }>;
}

declare module "material-ui/Card" {
  declare export var CardActions: $Exports<"material-ui/Card/CardActions">;
  declare export var CardContent: $Exports<"material-ui/Card/CardContent">;
  declare export var CardHeader: $Exports<"material-ui/Card/CardHeader">;
  declare export var CardMedia: $Exports<"material-ui/Card/CardMedia">;
  declare export default $Exports<"material-ui/Card/Card">;
}

declare module "material-ui/Checkbox/Checkbox" {
  declare module.exports: React$ComponentType<{
    checked?: boolean | string,
    checkedIcon?: React$Node,
    className?: string,
    classes?: Object,
    defaultChecked?: boolean,
    disableRipple?: boolean,
    disabled?: boolean,
    icon?: React$Node,
    indeterminate?: boolean,
    indeterminateIcon?: React$Node,
    inputProps?: Object,
    inputRef?: Function,
    name?: string,
    onChange?: Function,
    tabIndex?: number | string,
    value?: string
  }>;
}

declare module "material-ui/Checkbox" {
  declare module.exports: $Exports<"material-ui/Checkbox/Checkbox">;
}

declare module "material-ui/Chip/Chip" {
  import typeof Avatar from "material-ui/Avatar/Avatar";

  declare module.exports: React$ComponentType<{
    avatar?: React$Element<Avatar>,
    className?: string,
    classes?: Object,
    deleteIcon?: React$Element<any>,
    label?: React$Node,
    onClick?: Function,
    onDelete?: (event: SyntheticEvent<>) => void,
    onKeyDown?: Function,
    tabIndex?: number | string
  }>;
}

declare module "material-ui/Chip" {
  declare module.exports: $Exports<"material-ui/Chip/Chip">;
}

declare module "material-ui/CssBaseline/CssBaseline" {
  declare module.exports: React$ComponentType<{ children?: React$Node }>;
}

declare module "material-ui/CssBaseline" {
  declare module.exports: $Exports<"material-ui/CssBaseline/CssBaseline">;
}

declare module "material-ui/colors/amber" {
  declare module.exports: any;
}

declare module "material-ui/colors/blue" {
  declare module.exports: any;
}

declare module "material-ui/colors/blueGrey" {
  declare module.exports: any;
}

declare module "material-ui/colors/brown" {
  declare module.exports: any;
}

declare module "material-ui/colors/common" {
  declare module.exports: any;
}

declare module "material-ui/colors/cyan" {
  declare module.exports: any;
}

declare module "material-ui/colors/deepOrange" {
  declare module.exports: any;
}

declare module "material-ui/colors/deepPurple" {
  declare module.exports: any;
}

declare module "material-ui/colors/green" {
  declare module.exports: any;
}

declare module "material-ui/colors/grey" {
  declare module.exports: any;
}

declare module "material-ui/colors" {
  declare module.exports: any;
}

declare module "material-ui/colors/indigo" {
  declare module.exports: any;
}

declare module "material-ui/colors/lightBlue" {
  declare module.exports: any;
}

declare module "material-ui/colors/lightGreen" {
  declare module.exports: any;
}

declare module "material-ui/colors/lime" {
  declare module.exports: any;
}

declare module "material-ui/colors/orange" {
  declare module.exports: any;
}

declare module "material-ui/colors/pink" {
  declare module.exports: any;
}

declare module "material-ui/colors/purple" {
  declare module.exports: any;
}

declare module "material-ui/colors/red" {
  declare module.exports: any;
}

declare module "material-ui/colors/teal" {
  declare module.exports: any;
}

declare module "material-ui/colors/yellow" {
  declare module.exports: any;
}

declare module "material-ui/Dialog/Dialog" {
  import type {
    TransitionCallback,
    TransitionDuration
  } from "material-ui/internal/transition";
  declare type MaxWidth = "xs" | "sm" | "md" | false;

  declare module.exports: React$ComponentType<{
    children?: React$Node,
    className?: string,
    classes?: Object,
    fullScreen?: boolean,
    fullWidth?: boolean,
    ignoreBackdropClick?: boolean,
    ignoreEscapeKeyUp?: boolean,
    maxWidth?: MaxWidth,
    onBackdropClick?: Function,
    onClose?: Function,
    onEnter?: TransitionCallback,
    onEntered?: TransitionCallback,
    onEntering?: TransitionCallback,
    onEscapeKeyUp?: Function,
    onExit?: TransitionCallback,
    onExited?: TransitionCallback,
    onExiting?: TransitionCallback,
    open?: boolean,
    transition?: React$ComponentType<*>,
    transitionDuration?: TransitionDuration
  }>;
}

declare module "material-ui/Dialog/DialogActions" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    className?: string,
    classes?: Object
  }>;
}

declare module "material-ui/Dialog/DialogContent" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    className?: string,
    classes?: Object
  }>;
}

declare module "material-ui/Dialog/DialogContentText" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    className?: string,
    classes?: Object
  }>;
}

declare module "material-ui/Dialog/DialogTitle" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    className?: string,
    classes?: Object,
    disableTypography?: boolean
  }>;
}

declare module "material-ui/Dialog" {
  declare export var DialogActions: $Exports<
    "material-ui/Dialog/DialogActions"
  >;
  declare export var DialogContent: $Exports<
    "material-ui/Dialog/DialogContent"
  >;
  declare export var DialogContentText: $Exports<
    "material-ui/Dialog/DialogContentText"
  >;
  declare export var DialogTitle: $Exports<"material-ui/Dialog/DialogTitle">;
  declare export var withMobileDialog: $Exports<
    "material-ui/Dialog/withMobileDialog"
  >;
  declare export default $Exports<"material-ui/Dialog/Dialog">;
}

declare module "material-ui/Dialog/withMobileDialog" {
  declare module.exports: any;
}

declare module "material-ui/Divider/Divider" {
  declare module.exports: React$ComponentType<{
    absolute?: boolean,
    className?: string,
    classes?: Object,
    inset?: boolean,
    light?: boolean
  }>;
}

declare module "material-ui/Divider" {
  declare module.exports: $Exports<"material-ui/Divider/Divider">;
}

declare module "material-ui/Drawer/Drawer" {
  import type { TransitionDuration } from "material-ui/internal/transition";

  declare type Anchor = "left" | "top" | "right" | "bottom";
  declare type Type = "permanent" | "persistent" | "temporary";

  declare module.exports: React$ComponentType<{
    ModalProps?: Object,
    SlideProps?: Object,
    anchor?: Anchor,
    children: React$Node,
    className?: string,
    classes?: Object,
    elevation?: number,
    onClose?: Function,
    open?: boolean,
    transitionDuration?: TransitionDuration,
    type?: Type
  }>;
}
declare module "material-ui/Drawer" {
  declare module.exports: $Exports<"material-ui/Drawer/Drawer">;
}

declare module "material-ui/SwipeableDrawer/SwipeableDrawer" {
  import type { TransitionDuration } from "material-ui/internal/transition";

  declare type Anchor = "left" | "top" | "right" | "bottom";
  declare type Type = "permanent" | "persistent" | "temporary";

  declare module.exports: React$ComponentType<{
    ModalProps?: Object,
    SlideProps?: Object,
    anchor?: Anchor,
    children: React$Node,
    className?: string,
    classes?: Object,
    elevation?: number,
    onClose?: Function,
    open?: boolean,
    transitionDuration?: TransitionDuration,
    type?: Type
  }>;
}

declare module "material-ui/SwipeableDrawer" {
  declare module.exports: $Exports<
    "material-ui/SwipeableDrawer/SwipeableDrawer"
  >;
}

declare module "material-ui/ExpansionPanel/ExpansionPanel" {
  declare module.exports: React$ComponentType<{
    CollapseProps?: Object,
    children?: React$Node,
    className?: string,
    classes?: Object,
    defaultExpanded?: boolean,
    disabled?: boolean,
    expanded?: boolean,
    onChange?: Function
  }>;
}

declare module "material-ui/ExpansionPanel/ExpansionPanelActions" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    className?: string,
    classes?: Object
  }>;
}

declare module "material-ui/ExpansionPanel/ExpansionPanelDetails" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    className?: string,
    classes?: Object
  }>;
}

declare module "material-ui/ExpansionPanel/ExpansionPanelSummary" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    className?: string,
    classes?: Object,
    disabled?: boolean,
    expanded?: boolean,
    expandIcon?: React$Node,
    onChange?: Function,
    onClick?: Function
  }>;
}

declare module "material-ui/ExpansionPanel" {
  declare export default $Exports<"material-ui/ExpansionPanel/ExpansionPanel">;
  declare export var ExpansionPanelActions: $Exports<
    "material-ui/ExpansionPanel/ExpansionPanelActions"
  >;
  declare export var ExpansionPanelDetails: $Exports<
    "material-ui/ExpansionPanel/ExpansionPanelDetails"
  >;
  declare export var ExpansionPanelSummary: $Exports<
    "material-ui/ExpansionPanel/ExpansionPanelSummary"
  >;
}

declare module "material-ui/Form/FormControl" {
  declare type Margin = "none" | "dense" | "normal";

  declare module.exports: React$ComponentType<{
    children?: React$Node,
    classes?: Object,
    className?: string,
    component?: React$ElementType,
    disabled?: boolean,
    error?: boolean,
    fullWidth?: boolean,
    margin?: Margin,
    onBlur?: Function,
    onFocus?: Function,
    required?: boolean
  }>;
}

declare module "material-ui/Form/FormControlLabel" {
  declare module.exports: React$ComponentType<{
    checked?: boolean | string,
    classes?: Object,
    className?: string,
    control: React$Element<any>,
    disabled?: boolean,
    inputRef?: Function,
    label: React$Node,
    name?: string,
    onChange?: Function,
    value?: string
  }>;
}

declare module "material-ui/Form/FormGroup" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    classes?: Object,
    className?: string,
    row?: boolean
  }>;
}

declare module "material-ui/Form/FormHelperText" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    classes?: Object,
    className?: string,
    disabled?: boolean,
    error?: boolean,
    margin?: "dense"
  }>;
}

declare module "material-ui/Form/FormLabel" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    classes?: Object,
    className?: string,
    component?: React$ElementType,
    disabled?: boolean,
    error?: boolean,
    focused?: boolean,
    required?: boolean
  }>;
}

declare module "material-ui/Form" {
  declare module.exports: {
    FormGroup: $Exports<"material-ui/Form/FormGroup">,
    FormLabel: $Exports<"material-ui/Form/FormLabel">,
    FormControl: $Exports<"material-ui/Form/FormControl">,
    FormHelperText: $Exports<"material-ui/Form/FormHelperText">,
    FormControlLabel: $Exports<"material-ui/Form/FormControlLabel">
  };
}

declare module "material-ui/Grid/Grid" {
  declare type GridSizes =
    | boolean
    | 1
    | 2
    | 3
    | 4
    | 5
    | 6
    | 7
    | 8
    | 9
    | 10
    | 11
    | 12;
  declare type AlignContent =
    | "stretch"
    | "center"
    | "flex-start"
    | "flex-end"
    | "space-between"
    | "space-around";
  declare type AlignItems =
    | "flex-start"
    | "center"
    | "flex-end"
    | "stretch"
    | "baseline";
  declare type Direction = "row" | "row-reverse" | "column" | "column-reverse";
  declare type Justify =
    | "flex-start"
    | "center"
    | "flex-end"
    | "space-between"
    | "space-around";
  declare type Spacing = 0 | 8 | 16 | 24 | 40;
  declare type Wrap = "nowrap" | "wrap" | "wrap-reverse";

  declare module.exports: React$ComponentType<{
    children?: React$Node,
    classes?: Object,
    className?: string,
    component?: React$ElementType,
    container?: boolean,
    item?: boolean,
    alignContent?: AlignContent,
    alignItems?: AlignItems,
    direction?: Direction,
    spacing?: Spacing,
    hidden?: any,
    justify?: Justify,
    wrap?: Wrap,
    xs?: GridSizes,
    sm?: GridSizes,
    md?: GridSizes,
    lg?: GridSizes,
    xl?: GridSizes
  }>;
}

declare module "material-ui/Grid" {
  declare module.exports: $Exports<"material-ui/Grid/Grid">;
}

declare module "material-ui/GridList/GridList" {
  declare type CellHeight = number | "auto";

  declare module.exports: React$ComponentType<{
    cellHeight?: CellHeight,
    children: React$Node,
    classes?: Object,
    className?: string,
    cols?: number,
    component?: React$ElementType,
    spacing?: number,
    style?: Object
  }>;
}

declare module "material-ui/GridList/GridListTile" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    classes?: Object,
    className?: string,
    cols?: number,
    component?: React$ElementType,
    rows?: number
  }>;
}

declare module "material-ui/GridList/GridListTileBar" {
  declare type TitlePosition = "top" | "bottom";
  declare type ActionPosition = "left" | "right";

  declare module.exports: React$ComponentType<{
    actionIcon?: React$Node,
    actionPosition?: ActionPosition,
    classes?: Object,
    className?: string,
    subtitle?: React$Node,
    title: React$Node,
    titlePosition?: TitlePosition
  }>;
}

declare module "material-ui/GridList" {
  declare export default $Exports<"material-ui/GridList/GridList">;
  declare export var GridList: $Exports<"material-ui/GridList/GridList">;
  declare export var GridListTile: $Exports<
    "material-ui/GridList/GridListTile"
  >;
  declare export var GridListTileBar: $Exports<
    "material-ui/GridList/GridListTileBar"
  >;
}

declare module "material-ui/Hidden/Hidden" {
  import type { Breakpoint } from "material-ui/styles/createBreakpoints";

  declare module.exports: React$ComponentType<{
    children: React$Node,
    className?: string,
    only?: Breakpoint | Array<Breakpoint>,
    xsUp?: boolean,
    smUp?: boolean,
    mdUp?: boolean,
    lgUp?: boolean,
    xlUp?: boolean,
    xsDown?: boolean,
    smDown?: boolean,
    mdDown?: boolean,
    lgDown?: boolean,
    xlDown?: boolean,
    implementation?: "js" | "css",
    initialWidth?: number
  }>;
}

declare module "material-ui/Hidden/HiddenCss" {
  import typeof Hidden from "material-ui/Hidden/Hidden";

  declare module.exports: React$ComponentType<React$ElementProps<Hidden>>;
}

declare module "material-ui/Hidden/HiddenJs" {
  import typeof Hidden from "material-ui/Hidden/Hidden";

  declare module.exports: React$ComponentType<React$ElementProps<Hidden>>;
}

declare module "material-ui/Hidden" {
  declare export default $Exports<"material-ui/Hidden/Hidden">;
  declare export var HiddenJs: $Exports<"material-ui/Hidden/HiddenJs">;
}

declare module "material-ui/Hidden/types" {
  declare module.exports: any;
}

declare module "material-ui/Icon/Icon" {
  declare type Color =
    | "inherit"
    | "accent"
    | "action"
    | "contrast"
    | "disabled"
    | "error"
    | "primary";

  declare module.exports: React$ComponentType<{
    children?: React$Node,
    className?: string,
    classes?: Object,
    color?: Color
  }>;
}

declare module "material-ui/Icon" {
  declare module.exports: $Exports<"material-ui/Icon/Icon">;
}

declare module "material-ui/IconButton/IconButton" {
  declare type Color =
    | "default"
    | "inherit"
    | "primary"
    | "contrast"
    | "accent";

  declare module.exports: React$ComponentType<{
    buttonRef?: Function,
    children?: React$Node,
    classes?: Object,
    className?: string,
    color?: Color,
    disabled?: boolean,
    disableRipple?: boolean,
    rootRef?: Function
  }>;
}

declare module "material-ui/IconButton" {
  declare module.exports: $Exports<"material-ui/IconButton/IconButton">;
}

declare module "material-ui/Input" {
  declare export default $Exports<"material-ui/Input/Input">;
  declare export var InputAdornment: $Exports<
    "material-ui/Input/InputAdornment"
  >;
  declare export var InputLabel: $Exports<"material-ui/Input/InputLabel">;
}

declare module "material-ui/Input/Input" {
  declare module.exports: React$ComponentType<{
    autoComplete?: string,
    autoFocus?: boolean,
    classes?: Object,
    className?: string,
    defaultValue?: string | number,
    disabled?: boolean,
    disableUnderline?: boolean,
    endAdornment?: React$Node,
    error?: boolean,
    fullWidth?: boolean,
    id?: string,
    inputComponent?: string | React$ComponentType<*>,
    inputProps?: Object,
    inputRef?: Function,
    margin?: "dense" | "none",
    multiline?: boolean,
    name?: string,
    readOnly?: boolean,
    onBlur?: (event: SyntheticFocusEvent<>) => void,
    onChange?: (event: SyntheticInputEvent<>) => void,
    onClean?: () => void,
    onDirty?: () => void,
    onFocus?: (event: SyntheticFocusEvent<>) => void,
    onKeyDown?: (event: SyntheticKeyboardEvent<>) => void,
    onKeyUp?: (event: SyntheticKeyboardEvent<>) => void,
    placeholder?: string,
    rows?: string | number,
    rowsMax?: string | number,
    startAdornment?: React$Node,
    type?: string,
    value?: string | number | Array<string | number>
  }>;
}

declare module "material-ui/Input/InputAdornment" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    classes?: Object,
    className?: string,
    component?: React$ElementType,
    disableTypography?: boolean,
    position: "start" | "end"
  }>;
}

declare module "material-ui/Input/InputLabel" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    classes?: Object,
    className?: string,
    disableAnimation?: boolean,
    disabled?: boolean,
    error?: boolean,
    FormControlClasses?: Object,
    focused?: boolean,
    margin?: "dense",
    required?: boolean,
    shrink?: boolean
  }>;
}

declare module "material-ui/Input/Textarea" {
  declare type Rows = string | number;

  declare module.exports: React$ComponentType<{
    classes?: Object,
    className?: string,
    defaultValue?: string | number,
    disabled?: boolean,
    onChange?: Function,
    rows: Rows,
    rowsMax?: string | number,
    textareaRef?: Function,
    value?: string | number
  }>;
}

declare module "material-ui/internal/dom" {
  declare module.exports: any;
}

declare module "material-ui/Portal/Portal" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    open?: boolean
  }>;
}

declare module "material-ui/Portal" {
  declare module.exports: $Exports<"material-ui/Portal/Portal">;
}

declare module "material-ui/internal/SwitchBase" {
  declare module.exports: React$ComponentType<{
    checked?: boolean | string,
    checkedIcon?: React$Node,
    children?: React$Node,
    classes?: Object,
    className?: string,
    defaultChecked?: boolean,
    disabled?: boolean,
    disableRipple?: boolean,
    icon?: React$Node,
    indeterminate?: boolean,
    indeterminateIcon?: React$Node,
    inputProps?: Object,
    inputRef?: Function,
    inputType?: string,
    name?: string,
    onChange?: Function,
    tabIndex?: number | string,
    value?: string
  }>;
}

declare module "material-ui/internal/transition" {
  declare type TransitionDuration = number | { enter: number, exit: number };
  declare type TransitionCallback = (element: HTMLElement) => void;
  declare type TransitionClasses = {
    appear?: string,
    appearActive?: string,
    enter?: string,
    enterActive?: string,
    exit?: string,
    exitActive?: string
  };
}

declare module "material-ui/List" {
  declare module.exports: {
    ListItem: $Exports<"material-ui/List/ListItem">,
    ListItemAvatar: $Exports<"material-ui/List/ListItemAvatar">,
    ListItemText: $Exports<"material-ui/List/ListItemText">,
    ListItemIcon: $Exports<"material-ui/List/ListItemIcon">,
    ListItemSecondaryAction: $Exports<
      "material-ui/List/ListItemSecondaryAction"
    >,
    ListSubheader: $Exports<"material-ui/List/ListSubheader">
  };
}

declare module "material-ui/List/List" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    classes?: Object,
    className?: string,
    component?: React$ElementType,
    dense?: boolean,
    disablePadding?: boolean,
    rootRef?: Function,
    subheader?: React$Node
  }>;
}

declare module "material-ui/List/ListItem" {
  declare module.exports: React$ComponentType<{
    button?: boolean,
    children?: React$Node,
    classes?: Object,
    className?: string,
    component?: React$ElementType,
    dense?: boolean,
    disabled?: boolean,
    disableGutters?: boolean,
    divider?: boolean
  }>;
}

declare module "material-ui/List/ListItemAvatar" {
  declare module.exports: React$ComponentType<{
    children: React$Element<any>,
    classes?: Object,
    className?: string
  }>;
}

declare module "material-ui/List/ListItemIcon" {
  declare module.exports: React$ComponentType<{
    children: React$Element<any>,
    classes?: Object,
    className?: string
  }>;
}

declare module "material-ui/List/ListItemSecondaryAction" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    classes?: Object,
    className?: string
  }>;
}

declare module "material-ui/List/ListItemText" {
  declare module.exports: React$ComponentType<{
    classes?: Object,
    className?: string,
    disableTypography?: boolean,
    inset?: boolean,
    primary?: React$Node,
    secondary?: React$Node
  }>;
}

declare module "material-ui/List/ListSubheader" {
  declare type Color = "default" | "primary" | "inherit";

  declare module.exports: React$ComponentType<{
    children?: React$Node,
    classes?: Object,
    className?: string,
    component?: React$ElementType,
    color?: Color,
    disableSticky?: boolean,
    inset?: boolean
  }>;
}

declare module "material-ui/Menu" {
  declare export default $Exports<"material-ui/Menu/Menu">;
  declare export var MenuList: $Exports<"material-ui/Menu/MenuList">;
  declare export var MenuItem: $Exports<"material-ui/Menu/MenuItem">;
}

declare module "material-ui/Menu/Menu" {
  import type { TransitionCallback } from "material-ui/internal/transition";

  declare type TransitionDuration =
    | number
    | { enter?: number, exit?: number }
    | "auto";

  declare module.exports: React$ComponentType<{
    anchorEl?: ?HTMLElement,
    children?: React$Node,
    classes?: Object,
    MenuListProps?: Object,
    onEnter?: TransitionCallback,
    onEntering?: TransitionCallback,
    onEntered?: TransitionCallback,
    onExit?: TransitionCallback,
    onExiting?: TransitionCallback,
    onExited?: TransitionCallback,
    onClose?: Function,
    open?: boolean,
    PaperProps?: Object,
    PopoverClasses?: Object,
    transitionDuration?: TransitionDuration
  }>;
}

declare module "material-ui/Menu/MenuItem" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    classes?: Object,
    className?: string,
    component?: React$ElementType,
    role?: string,
    selected?: boolean
  }>;
}

declare module "material-ui/Menu/MenuList" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    className?: string,
    onBlur?: Function,
    onKeyDown?: (event: SyntheticUIEvent<>, key: string) => void
  }>;
}

declare module "material-ui/MobileStepper" {
  declare module.exports: $Exports<"material-ui/MobileStepper/MobileStepper">;
}

declare module "material-ui/MobileStepper/MobileStepper" {
  declare type Position = "bottom" | "top" | "static";
  declare type Type = "text" | "dots" | "progress";

  declare module.exports: React$ComponentType<{
    activeStep?: number,
    backButton: React$Element<any>,
    classes?: Object,
    className?: string,
    nextButton: React$Element<any>,
    position?: Position,
    steps: number,
    type?: Type
  }>;
}

declare module "material-ui/Modal/Backdrop" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    classes?: Object,
    className?: string,
    invisible?: boolean
  }>;
}

declare module "material-ui/Modal/ModalManager" {
  declare class ModalManager {
    constructor(Object): ModalManager;
    add(any, any): void;
    remove(any): number;
    isTopModal(modal: any): boolean;
  }
  declare export default typeof ModalManager;
}

declare module "material-ui/Modal" {
  declare export var Backdrop: $Exports<"material-ui/Modal/Backdrop">;
  declare export var ModalManager: $Exports<"material-ui/Modal/ModalManager">;
  declare export default $Exports<"material-ui/Modal/Modal">;
}

declare module "material-ui/Modal/Modal" {
  import type {
    TransitionDuration,
    TransitionCallback
  } from "material-ui/internal/transition";

  declare module.exports: React$ComponentType<{
    BackdropClassName?: string,
    BackdropComponent?: React$ElementType,
    BackdropInvisible?: boolean,
    BackdropTransitionDuration?: TransitionDuration,
    children?: React$Element<any>,
    classes?: Object,
    className?: string,
    keepMounted?: boolean,
    disableBackdrop?: boolean,
    ignoreBackdropClick?: boolean,
    ignoreEscapeKeyUp?: boolean,
    modalManager: Object,
    onBackdropClick?: Function,
    onEnter?: TransitionCallback,
    onEntering?: TransitionCallback,
    onEntered?: TransitionCallback,
    onEscapeKeyUp?: Function,
    onExit?: TransitionCallback,
    onExiting?: TransitionCallback,
    onExited?: TransitionCallback,
    onClose?: Function,
    show: boolean
  }>;
}

declare module "material-ui/Modal/modalManager" {
  declare module.exports: any;
}

declare module "material-ui/Paper" {
  declare module.exports: $Exports<"material-ui/Paper/Paper">;
}

declare module "material-ui/Paper/Paper" {
  declare module.exports: React$ComponentType<{
    classes?: Object,
    className?: string,
    children?: React$Node,
    component?: React$ElementType,
    elevation?: number,
    square?: boolean
  }>;
}

declare module "material-ui/Popover" {
  declare module.exports: $Exports<"material-ui/Popover/Popover">;
}

declare module "material-ui/Popover/Popover" {
  import type {
    TransitionCallback,
    TransitionClasses
  } from "material-ui/internal/transition";

  declare type Position = {
    top: number,
    left: number
  };

  declare type Origin = {
    horizontal: "left" | "center" | "right" | number,
    vertical: "top" | "center" | "bottom" | number
  };

  declare module.exports: React$ComponentType<{
    anchorEl?: ?HTMLElement,
    anchorPosition?: Position,
    anchorReference?: "anchorEl" | "anchorPosition",
    anchorOrigin?: Origin,
    children: React$Node,
    classes?: Object,
    elevation?: number,
    getContentAnchorEl?: Function,
    marginThreshold?: number,
    onEnter?: TransitionCallback,
    onEntering?: TransitionCallback,
    onEntered?: TransitionCallback,
    onExit?: TransitionCallback,
    onExiting?: TransitionCallback,
    onExited?: TransitionCallback,
    onClose?: Function,
    open: boolean,
    PaperProps?: Object,
    role?: string,
    transformOrigin?: Origin,
    transitionClasses?: TransitionClasses,
    transitionDuration?: number | { enter?: number, exit?: number } | "auto"
  }>;
}

declare module "material-ui/Progress/CircularProgress" {
  declare type Color = "primary" | "accent" | "inherit";
  declare type Mode = "determinate" | "indeterminate";

  declare module.exports: React$ComponentType<{
    classes?: Object,
    className?: string,
    color?: Color,
    max?: number,
    min?: number,
    mode?: Mode,
    size?: number,
    style?: Object,
    thickness?: number,
    value?: number
  }>;
}

declare module "material-ui/Progress" {
  declare module.exports: {
    CircularProgress: $Exports<"material-ui/Progress/CircularProgress">,
    LinearProgress: $Exports<"material-ui/Progress/LinearProgress">
  };
}

declare module "material-ui/Progress/LinearProgress" {
  declare type Color = "primary" | "accent";
  declare type Mode = "determinate" | "indeterminate" | "buffer" | "query";

  declare module.exports: React$ComponentType<{
    classes?: Object,
    className?: string,
    color?: Color,
    mode?: Mode,
    value?: number,
    valueBuffer?: number
  }>;
}

declare module "material-ui/Radio" {
  declare export default $Exports<"material-ui/Radio/Radio">;
  declare export var RadioGroup: $Exports<"material-ui/Radio/RadioGroup">;
}

declare module "material-ui/Radio/Radio" {
  declare module.exports: React$ComponentType<{
    checked?: boolean | string,
    checkedIcon?: React$Node,
    children?: React$Node,
    classes?: Object,
    className?: string,
    defaultChecked?: boolean,
    disabled?: boolean,
    disableRipple?: boolean,
    icon?: React$Node,
    inputProps?: Object,
    inputRef?: Function,
    name?: string,
    onChange?: Function,
    tabIndex?: number | string,
    value?: string
  }>;
}

declare module "material-ui/Radio/RadioGroup" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    name?: string,
    onBlur?: Function,
    onChange?: Function,
    onKeyDown?: Function,
    value?: string
  }>;
}

declare module "material-ui/Select" {
  declare module.exports: $Exports<"material-ui/Select/Select">;
}

declare module "material-ui/Select/Select" {
  import type { ChildrenArray } from "react";

  declare module.exports: React$ComponentType<{
    autoWidth?: boolean,
    children: ChildrenArray<*>,
    classes?: Object,
    displayEmpty?: boolean,
    input?: React$Element<any>,
    inputProps?: Object,
    native?: boolean,
    multiple?: boolean,
    onChange?: (event: SyntheticUIEvent<*>, child: Object) => void,
    onClose?: (event: SyntheticUIEvent<*>) => void,
    onOpen?: (event: SyntheticUIEvent<*>) => void,
    open?: boolean,
    MenuProps?: Object,
    renderValue?: Function,
    value?: $ReadOnlyArray<string | number> | string | number
  }>;
}

declare module "material-ui/Select/SelectInput" {
  declare module.exports: React$ComponentType<{
    autoWidth: boolean,
    children: React$Node,
    classes?: Object,
    className?: string,
    disabled?: boolean,
    displayEmpty: boolean,
    native: boolean,
    multiple: boolean,
    MenuProps?: Object,
    name?: string,
    onBlur?: Function,
    onChange?: (event: SyntheticUIEvent<*>, child: React$Element<any>) => void,
    onFocus?: Function,
    readOnly?: boolean,
    renderValue?: Function,
    selectRef?: Function,
    value?: string | number | $ReadOnlyArray<string | number>
  }>;
}

declare module "material-ui/Snackbar" {
  declare export default $Exports<"material-ui/Snackbar/Snackbar">;
  declare export var SnackbarContent: $Exports<
    "material-ui/Snackbar/SnackbarContent"
  >;
}

declare module "material-ui/Snackbar/Snackbar" {
  import type {
    TransitionDuration,
    TransitionCallback
  } from "material-ui/internal/transition";

  declare type Origin = {
    horizontal: "left" | "center" | "right" | number,
    vertical: "top" | "center" | "bottom" | number
  };

  declare module.exports: React$ComponentType<{
    action?: React$Node,
    anchorOrigin?: Origin,
    autoHideDuration?: ?number,
    resumeHideDuration?: number,
    children?: React$Element<any>,
    classes?: Object,
    className?: string,
    key?: any,
    message?: React$Node,
    onEnter?: TransitionCallback,
    onEntering?: TransitionCallback,
    onEntered?: TransitionCallback,
    onExit?: TransitionCallback,
    onExiting?: TransitionCallback,
    onExited?: TransitionCallback,
    onMouseEnter?: Function,
    onMouseLeave?: Function,
    onClose?: (event: ?Event, reason: string) => void,
    open: boolean,
    SnackbarContentProps?: Object,
    transition?: React$ComponentType<*>,
    transitionDuration?: TransitionDuration
  }>;
}

declare module "material-ui/Snackbar/SnackbarContent" {
  declare module.exports: React$ComponentType<{
    action?: React$Node,
    classes?: Object,
    className?: string,
    message: React$Node
  }>;
}

declare module "material-ui/Stepper" {
  declare export default $Exports<"material-ui/Stepper/Stepper">;
  declare export var Step: $Exports<"material-ui/Stepper/Step">;
  declare export var StepButton: $Exports<"material-ui/Stepper/StepButton">;
  declare export var StepContent: $Exports<"material-ui/Stepper/StepContent">;
  declare export var StepIcon: $Exports<"material-ui/Stepper/StepIcon">;
  declare export var StepLabel: $Exports<"material-ui/Stepper/StepLabel">;
}

declare module "material-ui/Stepper/Step" {
  import type { Orientation } from "material-ui/Stepper/Stepper";

  declare module.exports: React$ComponentType<{
    active?: boolean,
    alternativeLabel?: boolean,
    children?: React$Node,
    classes?: Object,
    className?: string,
    completed?: boolean,
    connector?: React$Element<any>,
    disabled?: boolean,
    index?: number,
    last?: boolean,
    optional?: boolean,
    orientation?: Orientation
  }>;
}

declare module "material-ui/Stepper/StepButton" {
  import type { Orientation } from "material-ui/Stepper/Stepper";

  declare type Icon = React$Element<any> | string | number;

  declare module.exports: React$ComponentType<{
    active?: boolean,
    alternativeLabel?: boolean,
    children: React$Element<any>,
    classes?: Object,
    className?: string,
    completed?: boolean,
    disabled?: boolean,
    icon?: Icon,
    last?: boolean,
    optional?: boolean,
    orientation: Orientation
  }>;
}

declare module "material-ui/Stepper/StepConnector" {
  import type { Orientation } from "material-ui/Stepper/Stepper";

  declare module.exports: React$ComponentType<{
    alternativeLabel?: boolean,
    classes?: Object,
    className?: string,
    orientation?: Orientation
  }>;
}

declare module "material-ui/Stepper/StepContent" {
  import type { TransitionDuration } from "material-ui/transitions/Collapse";
  import type { Orientation } from "material-ui/Stepper/Stepper";

  declare module.exports: React$ComponentType<{
    active?: boolean,
    alternativeLabel?: boolean,
    children: React$Node,
    classes?: Object,
    className?: string,
    completed?: boolean,
    last?: boolean,
    optional?: boolean,
    orientation?: Orientation,
    transition?: Function,
    transitionDuration?: TransitionDuration
  }>;
}

declare module "material-ui/Stepper/StepIcon" {
  import type { Icon } from "material-ui/Stepper/StepButton";

  declare module.exports: React$ComponentType<{
    active?: boolean,
    classes?: Object,
    completed?: boolean,
    icon?: Icon
  }>;
}

declare module "material-ui/Stepper/StepLabel" {
  import type { Orientation } from "material-ui/Stepper/Stepper";
  import type { Icon } from "material-ui/Stepper/StepButton";

  declare module.exports: React$ComponentType<{
    active?: boolean,
    alternativeLabel?: boolean,
    children: React$Node,
    classes?: Object,
    className?: string,
    completed?: boolean,
    disabled?: boolean,
    icon?: Icon,
    last?: boolean,
    optional?: boolean,
    orientation?: Orientation
  }>;
}

declare module "material-ui/Stepper/Stepper" {
  import type { ChildrenArray } from "react";
  import typeof Step from "material-ui/Stepper/Step";
  import typeof StepConnector from "material-ui/Stepper/StepConnector";

  declare type Orientation = "horizontal" | "vertical";

  declare module.exports: React$ComponentType<{
    activeStep?: number,
    alternativeLabel?: boolean,
    children: ChildrenArray<Element<Step>>,
    classes?: Object,
    className?: string,
    connector?: React$Element<StepConnector> | Node,
    nonLinear?: boolean,
    orientation?: Orientation
  }>;
}

declare module "material-ui/Stepper/StepPositionIcon" {
  import type { Icon } from "material-ui/Stepper/StepButton";

  declare module.exports: React$ComponentType<{
    active?: boolean,
    classes?: Object,
    className?: string,
    position?: Icon
  }>;
}

declare module "material-ui/styles/colorManipulator" {
  declare module.exports: {
    convertColorToString: (color: Object) => any,
    convertHexToRGB: (color: string) => any,
    decomposeColor: (color: string) => any,
    getContrastRatio: (foreground: string, background: string) => any,
    getLuminance: (color: string) => any,
    emphasize: (color: string, coefficient: number) => any,
    fade: (color: string, value: number) => any,
    darken: (color: string, coefficient: number) => any,
    ligthen: (color: string, coefficient: number) => any
  };
}

declare module "material-ui/styles/createBreakpoints" {
  declare type Breakpoint = "xs" | "sm" | "md" | "lg" | "xl";

  declare module.exports: {
    keys: Array<Breakpoint>,
    default: (breakpoints: Object) => any
  };
}

declare module "material-ui/styles/createGenerateClassName" {
  declare module.exports: () => any;
}

declare module "material-ui/styles/createMixins" {
  declare module.exports: (
    breakpoints: Object,
    spacing: Object,
    mixins: Object
  ) => any;
}

declare module "material-ui/styles/createMuiTheme" {
  declare module.exports: (options: Object) => any;
}

declare module "material-ui/styles/createPalette" {
  declare export var light: Object;
  declare export var dark: Object;
  declare export default (palette: Object) => any;
}

declare module "material-ui/styles/createTypography" {
  declare module.exports: (
    palette: Object,
    typography: Object | Function
  ) => any;
}

declare module "material-ui/styles/jssPreset" {
  declare module.exports: () => any;
}

declare module "material-ui/styles/getStylesCreator" {
  declare module.exports: (stylesOrCreator: Object | (Object => Object)) => any;
}

declare module "material-ui/styles" {
  declare module.exports: {
    MuiThemeProvider: $Exports<"material-ui/styles/MuiThemeProvider">,
    withStyles: $Exports<"material-ui/styles/withStyles">,
    withTheme: $Exports<"material-ui/styles/withTheme">,
    createMuiTheme: $Exports<"material-ui/styles/createMuiTheme">,
    jssPreset: $Exports<"material-ui/styles/jssPreset">
  };
}

declare module "material-ui/styles/MuiThemeProvider" {
  declare module.exports: React$ComponentType<Object>;
}

declare module "material-ui/styles/shadows" {
  declare module.exports: Array<any>;
}

declare module "material-ui/styles/spacing" {
  declare module.exports: Object;
}

declare module "material-ui/styles/themeListener" {
  declare export var CHANNEL: string;
  declare export default Object;
}

declare module "material-ui/styles/transitions" {
  declare export var easing: Object;
  declare export var duration: Object;
  declare export var formatMs: (milliseconds: number) => string;
  declare export var isString: (value: any) => boolean;
  declare export var isNumber: (value: any) => boolean;
  declare export default Object;
}

declare module "material-ui/styles/withStyles" {
  declare type Options = {
    flip?: boolean,
    withTheme?: boolean,
    name?: string,
    media?: string,
    meta?: string,
    index?: number,
    link?: boolean,
    element?: HTMLStyleElement,
    generateClassName?: Function
  };

  declare module.exports: (
    stylesOrCreator: Object,
    options?: Options
  ) => <
    OwnProps: {},
    Props: $Supertype<
      OwnProps & {
        classes: { +[string]: string },
        innerRef: React$Ref<React$ElementType>
      }
    >
  >(
    Component: React$ComponentType<Props>
  ) => React$ComponentType<OwnProps>;
}

declare module "material-ui/styles/withTheme" {
  declare module.exports: () => <Props: {}>(
    Component: React$ComponentType<Props>
  ) => React$ComponentType<Props>;
}

declare module "material-ui/styles/zIndex" {
  declare module.exports: Object;
}

declare module "material-ui/svg-icons/ArrowDownward" {
  declare module.exports: React$ComponentType<Object>;
}

declare module "material-ui/svg-icons/ArrowDropDown" {
  declare module.exports: React$ComponentType<Object>;
}

declare module "material-ui/svg-icons/Cancel" {
  declare module.exports: React$ComponentType<Object>;
}

declare module "material-ui/svg-icons/CheckBox" {
  declare module.exports: React$ComponentType<Object>;
}

declare module "material-ui/svg-icons/CheckBoxOutlineBlank" {
  declare module.exports: React$ComponentType<Object>;
}

declare module "material-ui/svg-icons/CheckCircle" {
  declare module.exports: React$ComponentType<Object>;
}

declare module "material-ui/svg-icons/IndeterminateCheckBox" {
  declare module.exports: React$ComponentType<Object>;
}

declare module "material-ui/svg-icons/KeyboardArrowLeft" {
  declare module.exports: React$ComponentType<Object>;
}

declare module "material-ui/svg-icons/KeyboardArrowRight" {
  declare module.exports: React$ComponentType<Object>;
}

declare module "material-ui/svg-icons/RadioButtonChecked" {
  declare module.exports: React$ComponentType<Object>;
}

declare module "material-ui/svg-icons/RadioButtonUnchecked" {
  declare module.exports: React$ComponentType<Object>;
}

declare module "material-ui/SvgIcon" {
  declare module.exports: $Exports<"material-ui/SvgIcon/SvgIcon">;
}

declare module "material-ui/SvgIcon/SvgIcon" {
  declare module.exports: React$ComponentType<{
    children: React$Node,
    classes?: Object,
    className?: string,
    titleAccess?: string,
    viewBox?: string
  }>;
}

declare module "material-ui/Switch" {
  declare module.exports: $Exports<"material-ui/Switch/Switch">;
}

declare module "material-ui/Switch/Switch" {
  declare module.exports: React$ComponentType<{
    checked?: boolean | string,
    checkedIcon?: React$Node,
    classes?: Object,
    className?: string,
    defaultChecked?: boolean,
    disabled?: boolean,
    disableRipple?: boolean,
    icon?: React$Node,
    inputProps?: Object,
    inputRef?: Function,
    name?: string,
    onChange?: Function,
    tabIndex?: number | string,
    value?: string
  }>;
}

declare module "material-ui/Table" {
  declare export default $Exports<"material-ui/Table/Table">;
  declare export var TableBody: $Exports<"material-ui/Table/TableBody">;
  declare export var TableCell: $Exports<"material-ui/Table/TableCell">;
  declare export var TableFooter: $Exports<"material-ui/Table/TableFooter">;
  declare export var TableHead: $Exports<"material-ui/Table/TableHead">;
  declare export var TablePagination: $Exports<
    "material-ui/Table/TablePagination"
  >;
  declare export var TableRow: $Exports<"material-ui/Table/TableRow">;
  declare export var TableSortLabel: $Exports<
    "material-ui/Table/TableSortLabel"
  >;
}

declare module "material-ui/Table/Table" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    classes?: Object,
    className?: string,
    component?: React$ElementType
  }>;
}

declare module "material-ui/Table/TableBody" {
  declare module.exports: React$ComponentType<{
    children?: React$Node,
    classes?: Object,
    className?: string,
    component?: React$ElementTy