Animate.d.ts

declare module 'preact-fluid/Animate' {

import { Component } from 'preact'
export type AnimateProps = {
  component: JSX.Element;
  animation?: {
    active?: boolean;
    duration?: number;
    timingFunction?: string;
    delay?: string;
    iterationCount?: number;
    direction?: string;
    fillMode?: string;
    playState?: string;
    onStart?: (...args: any[]) => any;
    onComplete?: (...args: any[]) => any;
    onIteration?: (...args: any[]) => any;
  };
  attrs?: object;
}
/**
 * Wrapper for animating the external component
 *
 * @example ./../../docs/components/Animate.md
 */
class Animate extends Component<AnimateProps, {}> {
  static defaultProps: {
    animation: {};
    attrs: {};
  }
  handleAnimationStart: () => void
  handleAnimationComplete: () => void
  handleAnimationIteration: () => void
  componentWillMount (): void
  componentDidMount (): void
  render (): JSX.Element
}
export default Animate

}

AppBar.d.ts

declare module 'preact-fluid/AppBar' {
import { Component, ComponentChild } from 'preact'
export interface AppBarProps {
  title?: string
  left?: any[]
  titleStyle?: {}
  logo?: any
  logoStyle?: {}
  leftSection?: ComponentChild
  rightSection?: ComponentChild
  primary?: boolean
  secondary?: boolean
}
/**
 * A toolbar that’s used for branding, navigation, search, and actions.
 *
 * @example ./../../docs/components/AppBar.md
 */
class AppBar extends Component<AppBarProps, {}> {
  static contextTypes: {
    theme: any;
  }
  render (): JSX.Element
}
export default AppBar
}

Button.d.ts

declare module 'preact-fluid/Button' {
import { Component } from 'preact'
export type ButtonProps = {
  size?: 'small' | 'normal' | 'large';
  rounded?: boolean;
  primary?: boolean;
  secondary?: boolean;
  disabled?: boolean;
  onClick?: (...args: any[]) => any;
}
/**
 * This button is used to add dimension to mostly flat layouts and emphasizes important functions on your page.
 *
 * @example ./../../docs/components/Button.md
 */
 class Button extends Component<ButtonProps, {}> {
   static defaultProps: {
     primary: boolean;
     secondary: boolean;
     clicked: boolean;
   }
   static contextTypes: {
     theme: any;
   }
   render (): JSX.Element
 }
export default Button
}

Card.d.ts

declare module 'preact-fluid/Card' {
import { Component } from 'preact'
export type CardProps = {
  style?: string;
  onClick?: (...args: any[]) => any;
}
/**
 * Cards are content containers to display information
 *
 * @example ./../../docs/components/Card.md
 */
class Card extends Component<CardProps, {}> {
  static contextTypes: {
    theme: any;
  }
  render (): JSX.Element
}
export default Card
}

CardBody.d.ts

declare module 'preact-fluid/CardBody' {
import { Component } from 'preact'
export type CardBodyProps = {
  style?: object;
}
/**
 * Cards header displays title information
 */
class CardBody extends Component<CardBodyProps, {}> {
  static contextTypes: {
    theme: any;
  }
  render (): JSX.Element
}
export default CardBody
}

CardFooter.d.ts

declare module 'preact-fluid/CardFooter' {
import { Component } from 'preact'
export type CardFooterProps = {
  style?: object;
}
/**
 * Cards header displays title information
 */
class CardFooter extends Component<CardFooterProps, {}> {
  static contextTypes: {
    theme: any;
  }
  render (): JSX.Element
}
export default CardFooter

}

CardHeader.d.ts

declare module 'preact-fluid/CardHeader' {
import { Component } from "preact";
export type CardHeaderProps = {
    style?: object;
};
/**
 * Cards header displays title information
 */
class CardHeader extends Component<CardHeaderProps, {}> {
    static contextTypes: {
        theme: any;
    };
    render(): JSX.Element;
}
export default CardHeader;

}

CardImage.d.ts

declare module 'preact-fluid/CardImage' {
import { Component } from 'preact'
/**
 * Cards header displays title information
 */
class CardImage extends Component {
  static propTypes: {
        /**
         * Custom styles
         */
    style: any;
  }
  static contextTypes: {
    theme: any;
  }
  renderOverlay: (overlay: any) => '' | JSX.Element
  render (): JSX.Element
}
export default CardImage

}

Cell.d.ts

declare module 'preact-fluid/Cell' {
import { Component } from 'preact'

export interface CellProps {
  width?: string
  height?: string
  left?: string
  top?: string
  center?: boolean
  area?: string
  middle?: boolean
  overflow?: boolean
  style?: string
}

/**
 * Cards are content containers to display information
 *
 * @example ./../../docs/components/Card.md
 */
class Cell extends Component<CellProps, {}> {
  render (): JSX.Element
}
export default Cell

}

Checkbox.d.ts

declare module 'preact-fluid/Checkbox' {
import { Component } from 'preact'
export type CheckboxProps = {
  style?: string;
  onChange?: (...args: any[]) => any;
  grid?: object;
  cell?: object;
  onClick?: (...args: any[]) => any;
}
/**
 * A checkbox is used to verify which options you want selected.
 *
 * @example ./../../../docs/components/Form/Checkbox.md
 */
class Checkbox extends Component<CheckboxProps, {}> {
  static defaultProps: {
    checked: boolean;
    disabled: boolean;
    grid: {
      columns: string;
      gap: string;
    };
    cell: {
      middle: boolean;
    };
  }
  static contextTypes: {
    theme: any;
  }
  readonly label: '' | JSX.Element
  handleOptionChange: (input: any) => void
  render (): JSX.Element
}
export default Checkbox

}

Dropdown.d.ts

declare module 'preact-fluid/Dropdown' {
import { Component } from 'preact'
export type DropdownProps = {
  component?: JSX.Element;
  openDropdown?: (...args: any[]) => any;
  closeDropdown?: (...args: any[]) => any;
  toggleDropdown?: (...args: any[]) => any;
  style?: object;
}
/**
 * Simple Dropdown component
 *
 * @example ./../../docs/components/Dropdown.md
 */
class Dropdown extends Component<DropdownProps, {}> {
  static defaultProps: {
    component: string;
  }
  static contextTypes: {
    theme: any;
  }
  handleClickOutside: (event: any) => void
  toggleDropdown: () => void
  closeDropdown: () => void
  openDropdown: () => void
  renderDropDown: () => JSX.Element
  componentDidMount (): void
  componentWillUnmount (): void
  render (): JSX.Element
}
export default Dropdown

}

Grid.d.ts

declare module 'preact-fluid/Grid' {
import { Component } from 'preact'

export interface GridProps {
  flow?: 'row' | 'column' | 'dense' | 'row dense' | 'column dense' | 'inherit' | 'initial' | 'unset'
  autoRows?: string
  rows?: string
  columns?: string
  gap?: string
  areas?: string[]
  justifyContent?: string
  alignItems?: string
  style?: string
}

/**
 * Layout layout
 *
 * @example ./../../docs/components/Grid.md
 */
class Grid extends Component<GridProps, {}> {
  render (): JSX.Element
}
export default Grid

}

Icon.d.ts

declare module 'preact-fluid/Icon' {
import { Component } from 'preact'
export type IconProps = {
  name: string;
  color?: string;
  size?: 'xsmall' | 'small' | 'normal' | 'large' | 'xlarge';
  onClick?: (...args: any[]) => any;
}
/**
 * This component will render font awesome icons only, include font awesome in your project.
 *
 * @example ./../../docs/components/Icon.md
 */
class Icon extends Component<IconProps, {}> {
  static defaultProps: {}
  render (): JSX.Element
}
export default Icon

}

Icon.spec.d.ts

declare module 'preact-fluid/Icon' {
export {};

}

Image.d.ts

declare module 'preact-fluid/Image' {
import { Component } from 'preact'
export type ImageProps = {
  style?: string;
  onClick?: (...args: any[]) => any;
}
/**
 * Progressive Image Loading with a blur effect option to reduce the page load time
 *
 * @example ./../../docs/components/Image.md
 */
class Image extends Component<ImageProps, {}> {
  handleImageLoaded: () => void
  handleImageErrored: () => void
  renderResponsiveImages: (images?: any[]) => JSX.Element[]
  placeholderOnLoad: (element: any) => void
  renderPlaceholder: (placeholder: any) => '' | JSX.Element
  render (): JSX.Element
}
export default Image

}

index.d.ts

declare module 'preact-fluid' {
  import Animate from 'preact-fluid/Animate'
  import AppBar from 'preact-fluid/AppBar'
  import Button from 'preact-fluid/Button'
  import CardBody from 'preact-fluid/CardBody'
  import Card from 'preact-fluid/Card'
  import CardFooter from 'preact-fluid/CardFooter'
  import CardHeader from 'preact-fluid/CardHeader'
  import CardImage from 'preact-fluid/CardImage'
  import Cell from 'preact-fluid/Cell'
  import Checkbox from 'preact-fluid/Checkbox'
  import Dropdown from 'preact-fluid/Dropdown'
  import Grid from 'preact-fluid/Grid'
  import Icon from 'preact-fluid/Icon'
  import Image from 'preact-fluid/Image'
  import Link from 'preact-fluid/Link'
  import List from 'preact-fluid/List'
  import ListFooter from 'preact-fluid/ListFooter'
  import ListHeader from 'preact-fluid/ListHeader'
  import ListItem from 'preact-fluid/ListItem'
  import ListSection from 'preact-fluid/ListSection'
  import Modal from 'preact-fluid/Modal'
  import ModalPortal from 'preact-fluid/ModalPortal'
  import Notify from 'preact-fluid/Notify'
  import NotifyPanel from 'preact-fluid/NotifyPanel'
  import NotifyPortal from 'preact-fluid/NotifyPortal'
  import Radio from 'preact-fluid/Radio'
  import RadioGroup from 'preact-fluid/RadioGroup'
  import TextField from 'preact-fluid/TextField'
  import Tooltip from 'preact-fluid/Tooltip'
  let _export: {
    Animate: typeof Animate,
    AppBar: typeof AppBar,
    Button: typeof Button,
    CardBody: typeof CardBody,
    Card: typeof Card,
    CardFooter: typeof CardFooter,
    CardHeader: typeof CardHeader,
    CardImage: typeof CardImage,
    Cell: typeof Cell,
    Checkbox: typeof Checkbox,
    Dropdown: typeof Dropdown,
    Grid: typeof Grid,
    Icon: typeof Icon,
    Image: typeof Image,
    Link: typeof Link,
    List: typeof List,
    ListFooter: typeof ListFooter,
    ListHeader: typeof ListHeader,
    ListItem: typeof ListItem,
    ListSection: typeof ListSection,
    Modal: typeof Modal,
    ModalPortal: typeof ModalPortal,
    Notify: typeof Notify,
    NotifyPanel: typeof NotifyPanel,
    NotifyPortal: typeof NotifyPortal,
    Radio: typeof Radio,
    RadioGroup: typeof RadioGroup,
    TextField: typeof TextField,
    Tooltip: typeof Tooltip
  }
  export = _export
}

keyframes.d.ts

declare module 'preact-fluid/keyframes' {
const _default: {
  buttonEffect: string;
  loading: string;
}
export default _default
}

Link.d.ts

declare module 'preact-fluid/Link' {
import { Component } from 'preact'
export type LinkProps = {
  href?: string;
  style?: object;
  onClick?: (...args: any[]) => any;
}
/**
 * Provides declarative, accessible navigation around your application.
 *
 * @example ./../../docs/components/Link.md
 */
class Link extends Component<LinkProps, {}> {
  static contextTypes: {
    theme: any;
  }
  render (): JSX.Element
}
export default Link

}

List.d.ts

declare module 'preact-fluid/List' {
import { Component } from 'preact'
export type ListProps = {
  style?: object;
}
/**
 * List groups are a flexible and powerful component for displaying not only simple lists of elements, but complex ones with custom content.
 *
 * @example ./../../docs/components/List.md
 */
class List extends Component<ListProps, {}> {
  static contextTypes: {
    theme: any;
  }
  render (): JSX.Element
}
export default List

}

ListFooter.d.ts

declare module 'preact-fluid/ListFooter' {
import { Component } from 'preact'
export type ListFooterProps = {
  style?: object;
}
/**
 * List Footer - https://dribbble.com/shots/3935136-MrWhite-UI-Kit-Dropdown-s/attachments/897751
 */
class ListFooter extends Component<ListFooterProps, {}> {
  static contextTypes: {
    theme: any;
  }
  render (): JSX.Element
}
export default ListFooter

}

ListHeader.d.ts

declare module 'preact-fluid/ListHeader' {
import { Component } from 'preact'
export type ListHeaderProps = {
  style?: object;
}
/**
 * List header
 */
class ListHeader extends Component<ListHeaderProps, {}> {
  static contextTypes: {
    theme: any;
  }
  readonly content: any
  render (): JSX.Element
}
export default ListHeader

}

ListItem.d.ts

declare module 'preact-fluid/ListItem' {
import { Component } from 'preact'
export type ListItemProps = {
  style?: object;
}
/**
 * List Item
 */
class ListItem extends Component<ListItemProps, {}> {
  static contextTypes: {
    theme: any;
  }
  readonly left: '' | JSX.Element
  readonly right: '' | JSX.Element
  handleClick: () => void
  render (): JSX.Element
}
export default ListItem

}

ListSection.d.ts

declare module 'preact-fluid/ListSection' {
import { Component } from 'preact'
export type ListSectionProps = {
  style?: object;
}
/**
 * List Section
 */
class ListSection extends Component<ListSectionProps, {}> {
  static contextTypes: {
    theme: any;
  }
  render (): JSX.Element
}
export default ListSection

}

Modal.d.ts

declare module 'preact-fluid/Modal' {
import { Component } from 'preact'
export type ModalProps = {
  style?: object;
}
export type ModalState = {
  content: boolean;
}
/**
 * Description
 *
 * @example ./../../docs/components/Modal.md
 */
class Modal extends Component<ModalProps, ModalState> {
  static defaultProps: {}
  static contextTypes: {
    theme: any;
  }
  show: (content: any) => void
  hide: () => void
  constructor (props: any);
  render (): JSX.Element
}
export default Modal

}

ModalPortal.d.ts

declare module 'preact-fluid/ModalPortal' {
import { Component } from 'preact'
/**
 * Modal Portal Component
 */
class ModalPortal extends Component<{}, {}> {
  render: () => any
  constructor (props: any);
  componentDidMount (): void
  componentWillUnmount (): void
  componentDidUpdate (): void
}
export default ModalPortal

}

Notify.d.ts

declare module 'preact-fluid/Notify' {
import { Component } from 'preact'
export type NotifyProps = {
  id?: string;
  style?: object;
  title?: string;
  autoDismiss?: number;
  message?: string;
  type?: 'success' | 'warning' | 'error' | 'info';
  onClick?: (...args: any[]) => any;
  iconName?: string;
  iconSize?: 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge';
  iconColor?: string;
  onAdd?: (...args: any[]) => any;
  onDismiss?: (...args: any[]) => any;
}
export type NotifyState = {
  notifications: undefined[];
}
/**
 * Notification system for application with customizable features
 *
 * @example ./../../docs/components/Notify.md
 */
class Notify extends Component<NotifyProps, NotifyState> {
  static defaultProps: {
    type: string;
    style: {};
    title: any;
    message: any;
    autoDismiss: number;
    iconName: string;
    iconColor: string;
    iconSize: string;
  }
  readonly guid: string
  add: (notification: any) => void
  dismiss: (notification: any) => void
  renderNotification: () => JSX.Element[]
  constructor (props: any);
  render (): JSX.Element
}
export default Notify

}

NotifyPanel.d.ts

declare module 'preact-fluid/NotifyPanel' {
import { Component } from 'preact'
export type NotifyPanelProps = {
  style?: object;
  title?: string;
  autoDismiss?: any;
  message?: string;
  type?: 'success' | 'warning' | 'error' | 'info';
  onClick?: (...args: any[]) => any;
  iconName?: string;
  iconSize?: 'xsmall' | 'small' | 'medium' | 'large' | 'xlarge';
  iconColor?: string;
}
/**
 * Notification panel
 */
class NotifyPanel extends Component<NotifyPanelProps, {}> {
  static defaultProps: {
    type: string;
  }
  static contextTypes: {
    theme: any;
  }
  readonly iconColor: any
  close: () => void
  onClick: () => void
  render (): JSX.Element
}
export default NotifyPanel

}

NotifyPortal.d.ts

declare module 'preact-fluid/NotifyPortal' {
import { Component } from 'preact'
/**
 * Notification Portal Component
 */
class NotifyPortal extends Component<{}, {}> {
  render: () => any
  constructor (props: any);
  componentDidMount (): void
  componentWillUnmount (): void
  componentDidUpdate (): void
}
export default NotifyPortal

}

Radio.d.ts

declare module 'preact-fluid/Radio' {
import { Component } from 'preact'
export type RadioProps = {
  style?: string;
  onChange?: (...args: any[]) => any;
  grid?: object;
  cell?: object;
  effect?: 'default' | 'circle' | 'drop';
  bgColor?: string;
  highlightColor?: string;
}
/**
 * Radio are switches used for selection
 *
 * @example ./../../../docs/components/Form/Radio.md
 */
class Radio extends Component<RadioProps, {}> {
  static defaultProps: {
    grid: {
      columns: string;
      gap: string;
    };
    cell: {
      middle: boolean;
    };
    effect: string;
    checked: boolean;
  }
  static contextTypes: {
    theme: any;
  }
  readonly label: '' | JSX.Element
  handleOptionChange: (input: any) => void
  render (): JSX.Element
}
export default Radio

}

RadioGroup.d.ts

declare module 'preact-fluid/RadioGroup' {
import { Component } from 'preact'
export type RadioGroupProps = {
  style?: string;
  defaultSelected?: string;
  onChange?: (...args: any[]) => any;
  horizontal?: boolean;
  grid?: object;
  cell?: object;
  hideLabel?: boolean;
  disabled?: boolean;
}
/**
 * Radio are switches used for selection from multiple options
 *
 * @example ./../../../docs/components/Form/RadioGroup.md
 */
class RadioGroup extends Component<RadioGroupProps, {}> {
  static defaultProps: {
    defaultSelected: any;
    style: string;
    horizontal: boolean;
    grid: {
      columns: string;
    };
    cell: {
      middle: boolean;
    };
    hideLabel: boolean;
    disabled: boolean;
  }
  readonly label: '' | JSX.Element
  readonly selectedValue: any
  handleOnChange: (input: any) => void
  renderRadio: (child: any, index: any) => JSX.Element
  render (): JSX.Element
}
export default RadioGroup

}

styles.d.ts

declare module 'preact-fluid/styles' {
declare const StyledTooltip: import("styled-components").StyledComponentClass<JSX.HTMLAttributes, any, JSX.HTMLAttributes>;
export { StyledTooltip };

}

TextField.d.ts

declare module 'preact-fluid/TextField' {
import { Component } from 'preact'
export type TextFieldProps = {
  style?: string;
  onChange?: (...args: any[]) => any;
  grid?: object;
  cell?: object;
}
/**
 * TextField allow users to input text.
 *
 * @example ./../../../docs/components/Form/TextField.md
 */
class TextField extends Component<TextFieldProps, {}> {
  static defaultProps: {
    style: string;
    grid: {
      columns: string;
    };
    cell: {
      middle: boolean;
    };
    hideLabel: boolean;
  }
  static contextTypes: {
    theme: any;
  }
  readonly label: '' | JSX.Element
  onChange: (input: any) => void
  renderErrorMessage: (errorText: any) => '' | JSX.Element
  render (): JSX.Element
}
export default TextField

}

theme.d.ts

declare module 'preact-fluid/theme' {
const _default: {
  primaryColor: string;
  primaryColorDark: string;
  primaryColorLight: string;
  secondaryColor: string;
  secondaryColorDark: string;
  secondaryColorLight: string;
  linkColor: string;
  linkColorDark: string;
  darkColor: string;
  lightColor: string;
  grayColor: string;
  grayColorLight: string;
  grayColorDark: string;
  borderColor: string;
  borderColorDark: string;
  bgColor: string;
  bgColorDark: string;
  bgColorLight: string;
  controlSuccessColor: string;
  controlWarningColor: string;
  controlErrorColor: string;
  codeColor: string;
  highlightColor: string;
  notifyBgColor: string;
  listActiveColor: string;
}
export default _default

}

Tooltip.d.ts

declare module 'preact-fluid/Tooltip' {
import { Component } from 'preact'
export type TooltipProps = {
  title: object;
  position?: 'top' | 'bottom' | 'left' | 'right';
  effect?: 'fade' | 'expand';
  width?: string;
  style?: object;
}
/**
 * Description
 *
 * @example ./../../docs/components/Tooltip.md
 */
class Tooltip extends Component<TooltipProps, {}> {
  static defaultProps: {
    title: string;
    effect: string;
    position: string;
    width: any;
  }
  static contextTypes: {
    theme: any;
  }
  render (): JSX.Element
}
export default Tooltip

}