/**
 * This is an autogenerated file created by the Stencil build process.
 * It contains typing information for all components that exist in this project
 * and imports for stencil collections that might be configured in your stencil.config.js file
 */

import 'ionicons';

import { ActionSheetController as IonActionSheetController } from './components/action-sheet-controller/action-sheet-controller';

interface HTMLIonActionSheetControllerElement extends IonActionSheetController, HTMLElement {
}
declare var HTMLIonActionSheetControllerElement: {
  prototype: HTMLIonActionSheetControllerElement;
  new (): HTMLIonActionSheetControllerElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-action-sheet-controller": HTMLIonActionSheetControllerElement;
  }
  interface ElementTagNameMap {
      "ion-action-sheet-controller": HTMLIonActionSheetControllerElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-action-sheet-controller": JSXElements.IonActionSheetControllerAttributes;
      }
  }
  namespace JSXElements {
      export interface IonActionSheetControllerAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          create?: any
      }
  }
}

import { ActionSheet as IonActionSheet } from './components/action-sheet/action-sheet';

interface HTMLIonActionSheetElement extends IonActionSheet, HTMLElement {
}
declare var HTMLIonActionSheetElement: {
  prototype: HTMLIonActionSheetElement;
  new (): HTMLIonActionSheetElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-action-sheet": HTMLIonActionSheetElement;
  }
  interface ElementTagNameMap {
      "ion-action-sheet": HTMLIonActionSheetElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-action-sheet": JSXElements.IonActionSheetAttributes;
      }
  }
  namespace JSXElements {
      export interface IonActionSheetAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          animationCtrl?: any,
          cssClass?: string,
          title?: string,
          subTitle?: string,
          buttons?: any,
          enableBackdropDismiss?: boolean,
          enterAnimation?: any,
          exitAnimation?: any,
          actionSheetId?: string
      }
  }
}

import { AlertController as IonAlertController } from './components/alert-controller/alert-controller';

interface HTMLIonAlertControllerElement extends IonAlertController, HTMLElement {
}
declare var HTMLIonAlertControllerElement: {
  prototype: HTMLIonAlertControllerElement;
  new (): HTMLIonAlertControllerElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-alert-controller": HTMLIonAlertControllerElement;
  }
  interface ElementTagNameMap {
      "ion-alert-controller": HTMLIonAlertControllerElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-alert-controller": JSXElements.IonAlertControllerAttributes;
      }
  }
  namespace JSXElements {
      export interface IonAlertControllerAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          create?: any
      }
  }
}

import { Alert as IonAlert } from './components/alert/alert';

interface HTMLIonAlertElement extends IonAlert, HTMLElement {
}
declare var HTMLIonAlertElement: {
  prototype: HTMLIonAlertElement;
  new (): HTMLIonAlertElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-alert": HTMLIonAlertElement;
  }
  interface ElementTagNameMap {
      "ion-alert": HTMLIonAlertElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-alert": JSXElements.IonAlertAttributes;
      }
  }
  namespace JSXElements {
      export interface IonAlertAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          animationCtrl?: any,
          cssClass?: string,
          title?: string,
          subTitle?: string,
          message?: string,
          buttons?: any,
          inputs?: any,
          enableBackdropDismiss?: boolean,
          enterAnimation?: any,
          exitAnimation?: any,
          alertId?: string
      }
  }
}

import { AnimationControllerImpl as IonAnimationController } from './components/animation-controller/animation-controller';

interface HTMLIonAnimationControllerElement extends IonAnimationController, HTMLElement {
}
declare var HTMLIonAnimationControllerElement: {
  prototype: HTMLIonAnimationControllerElement;
  new (): HTMLIonAnimationControllerElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-animation-controller": HTMLIonAnimationControllerElement;
  }
  interface ElementTagNameMap {
      "ion-animation-controller": HTMLIonAnimationControllerElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-animation-controller": JSXElements.IonAnimationControllerAttributes;
      }
  }
  namespace JSXElements {
      export interface IonAnimationControllerAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          create?: any
      }
  }
}

import { IonApp as IonApp } from './components/app/app';

interface HTMLIonAppElement extends IonApp, HTMLElement {
}
declare var HTMLIonAppElement: {
  prototype: HTMLIonAppElement;
  new (): HTMLIonAppElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-app": HTMLIonAppElement;
  }
  interface ElementTagNameMap {
      "ion-app": HTMLIonAppElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-app": JSXElements.IonAppAttributes;
      }
  }
  namespace JSXElements {
      export interface IonAppAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { Avatar as IonAvatar } from './components/avatar/avatar';

interface HTMLIonAvatarElement extends IonAvatar, HTMLElement {
}
declare var HTMLIonAvatarElement: {
  prototype: HTMLIonAvatarElement;
  new (): HTMLIonAvatarElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-avatar": HTMLIonAvatarElement;
  }
  interface ElementTagNameMap {
      "ion-avatar": HTMLIonAvatarElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-avatar": JSXElements.IonAvatarAttributes;
      }
  }
  namespace JSXElements {
      export interface IonAvatarAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { Backdrop as IonBackdrop } from './components/backdrop/backdrop';

interface HTMLIonBackdropElement extends IonBackdrop, HTMLElement {
}
declare var HTMLIonBackdropElement: {
  prototype: HTMLIonBackdropElement;
  new (): HTMLIonBackdropElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-backdrop": HTMLIonBackdropElement;
  }
  interface ElementTagNameMap {
      "ion-backdrop": HTMLIonBackdropElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-backdrop": JSXElements.IonBackdropAttributes;
      }
  }
  namespace JSXElements {
      export interface IonBackdropAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { Badge as IonBadge } from './components/badge/badge';

interface HTMLIonBadgeElement extends IonBadge, HTMLElement {
}
declare var HTMLIonBadgeElement: {
  prototype: HTMLIonBadgeElement;
  new (): HTMLIonBadgeElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-badge": HTMLIonBadgeElement;
  }
  interface ElementTagNameMap {
      "ion-badge": HTMLIonBadgeElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-badge": JSXElements.IonBadgeAttributes;
      }
  }
  namespace JSXElements {
      export interface IonBadgeAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { Button as IonButton } from './components/button/button';

interface HTMLIonButtonElement extends IonButton, HTMLElement {
}
declare var HTMLIonButtonElement: {
  prototype: HTMLIonButtonElement;
  new (): HTMLIonButtonElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-button": HTMLIonButtonElement;
  }
  interface ElementTagNameMap {
      "ion-button": HTMLIonButtonElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-button": JSXElements.IonButtonAttributes;
      }
  }
  namespace JSXElements {
      export interface IonButtonAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          itemButton?: boolean,
          href?: string,
          buttonType?: string,
          large?: boolean,
          small?: boolean,
          default?: boolean,
          disabled?: boolean,
          outline?: boolean,
          clear?: boolean,
          solid?: boolean,
          round?: boolean,
          block?: boolean,
          full?: boolean,
          strong?: boolean
      }
  }
}

import { Buttons as IonButtons } from './components/buttons/buttons';

interface HTMLIonButtonsElement extends IonButtons, HTMLElement {
}
declare var HTMLIonButtonsElement: {
  prototype: HTMLIonButtonsElement;
  new (): HTMLIonButtonsElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-buttons": HTMLIonButtonsElement;
  }
  interface ElementTagNameMap {
      "ion-buttons": HTMLIonButtonsElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-buttons": JSXElements.IonButtonsAttributes;
      }
  }
  namespace JSXElements {
      export interface IonButtonsAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { CardContent as IonCardContent } from './components/card-content/card-content';

interface HTMLIonCardContentElement extends IonCardContent, HTMLElement {
}
declare var HTMLIonCardContentElement: {
  prototype: HTMLIonCardContentElement;
  new (): HTMLIonCardContentElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-card-content": HTMLIonCardContentElement;
  }
  interface ElementTagNameMap {
      "ion-card-content": HTMLIonCardContentElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-card-content": JSXElements.IonCardContentAttributes;
      }
  }
  namespace JSXElements {
      export interface IonCardContentAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { CardHeader as IonCardHeader } from './components/card-header/card-header';

interface HTMLIonCardHeaderElement extends IonCardHeader, HTMLElement {
}
declare var HTMLIonCardHeaderElement: {
  prototype: HTMLIonCardHeaderElement;
  new (): HTMLIonCardHeaderElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-card-header": HTMLIonCardHeaderElement;
  }
  interface ElementTagNameMap {
      "ion-card-header": HTMLIonCardHeaderElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-card-header": JSXElements.IonCardHeaderAttributes;
      }
  }
  namespace JSXElements {
      export interface IonCardHeaderAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { CardTitle as IonCardTitle } from './components/card-title/card-title';

interface HTMLIonCardTitleElement extends IonCardTitle, HTMLElement {
}
declare var HTMLIonCardTitleElement: {
  prototype: HTMLIonCardTitleElement;
  new (): HTMLIonCardTitleElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-card-title": HTMLIonCardTitleElement;
  }
  interface ElementTagNameMap {
      "ion-card-title": HTMLIonCardTitleElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-card-title": JSXElements.IonCardTitleAttributes;
      }
  }
  namespace JSXElements {
      export interface IonCardTitleAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { Card as IonCard } from './components/card/card';

interface HTMLIonCardElement extends IonCard, HTMLElement {
}
declare var HTMLIonCardElement: {
  prototype: HTMLIonCardElement;
  new (): HTMLIonCardElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-card": HTMLIonCardElement;
  }
  interface ElementTagNameMap {
      "ion-card": HTMLIonCardElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-card": JSXElements.IonCardAttributes;
      }
  }
  namespace JSXElements {
      export interface IonCardAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { Checkbox as IonCheckbox } from './components/checkbox/checkbox';

interface HTMLIonCheckboxElement extends IonCheckbox, HTMLElement {
}
declare var HTMLIonCheckboxElement: {
  prototype: HTMLIonCheckboxElement;
  new (): HTMLIonCheckboxElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-checkbox": HTMLIonCheckboxElement;
  }
  interface ElementTagNameMap {
      "ion-checkbox": HTMLIonCheckboxElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-checkbox": JSXElements.IonCheckboxAttributes;
      }
  }
  namespace JSXElements {
      export interface IonCheckboxAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          checked?: boolean,
          disabled?: boolean,
          value?: string
      }
  }
}

import { ChipButton as IonChipButton } from './components/chip-button/chip-button';

interface HTMLIonChipButtonElement extends IonChipButton, HTMLElement {
}
declare var HTMLIonChipButtonElement: {
  prototype: HTMLIonChipButtonElement;
  new (): HTMLIonChipButtonElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-chip-button": HTMLIonChipButtonElement;
  }
  interface ElementTagNameMap {
      "ion-chip-button": HTMLIonChipButtonElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-chip-button": JSXElements.IonChipButtonAttributes;
      }
  }
  namespace JSXElements {
      export interface IonChipButtonAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          href?: string,
          clear?: boolean,
          disabled?: boolean
      }
  }
}

import { Chip as IonChip } from './components/chip/chip';

interface HTMLIonChipElement extends IonChip, HTMLElement {
}
declare var HTMLIonChipElement: {
  prototype: HTMLIonChipElement;
  new (): HTMLIonChipElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-chip": HTMLIonChipElement;
  }
  interface ElementTagNameMap {
      "ion-chip": HTMLIonChipElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-chip": JSXElements.IonChipAttributes;
      }
  }
  namespace JSXElements {
      export interface IonChipAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { Content as IonContent } from './components/content/content';

interface HTMLIonContentElement extends IonContent, HTMLElement {
}
declare var HTMLIonContentElement: {
  prototype: HTMLIonContentElement;
  new (): HTMLIonContentElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-content": HTMLIonContentElement;
  }
  interface ElementTagNameMap {
      "ion-content": HTMLIonContentElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-content": JSXElements.IonContentAttributes;
      }
  }
  namespace JSXElements {
      export interface IonContentAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          enableJsScroll?: any,
          scrollToTop?: any,
          scrollToBottom?: any,
          ionScrollStart?: any,
          ionScroll?: any,
          ionScrollEnd?: any,
          fullscreen?: boolean
      }
  }
}

import { Datetime as IonDatetime } from './components/datetime/datetime';

interface HTMLIonDatetimeElement extends IonDatetime, HTMLElement {
}
declare var HTMLIonDatetimeElement: {
  prototype: HTMLIonDatetimeElement;
  new (): HTMLIonDatetimeElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-datetime": HTMLIonDatetimeElement;
  }
  interface ElementTagNameMap {
      "ion-datetime": HTMLIonDatetimeElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-datetime": JSXElements.IonDatetimeAttributes;
      }
  }
  namespace JSXElements {
      export interface IonDatetimeAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          pickerCtrl?: any,
          disabled?: boolean,
          min?: string,
          max?: string,
          displayFormat?: string,
          pickerFormat?: string,
          cancelText?: string,
          doneText?: string,
          yearValues?: any,
          monthValues?: any,
          dayValues?: any,
          hourValues?: any,
          minuteValues?: any,
          monthNames?: any,
          monthShortNames?: any,
          dayNames?: any,
          dayShortNames?: any,
          pickerOptions?: any,
          placeholder?: string,
          value?: string
      }
  }
}

import { FabContainer as IonFab } from './components/fab/fab-container';

interface HTMLIonFabElement extends IonFab, HTMLElement {
}
declare var HTMLIonFabElement: {
  prototype: HTMLIonFabElement;
  new (): HTMLIonFabElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-fab": HTMLIonFabElement;
  }
  interface ElementTagNameMap {
      "ion-fab": HTMLIonFabElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-fab": JSXElements.IonFabAttributes;
      }
  }
  namespace JSXElements {
      export interface IonFabAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          close?: any
      }
  }
}

import { FabList as IonFabList } from './components/fab/fab-list';

interface HTMLIonFabListElement extends IonFabList, HTMLElement {
}
declare var HTMLIonFabListElement: {
  prototype: HTMLIonFabListElement;
  new (): HTMLIonFabListElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-fab-list": HTMLIonFabListElement;
  }
  interface ElementTagNameMap {
      "ion-fab-list": HTMLIonFabListElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-fab-list": JSXElements.IonFabListAttributes;
      }
  }
  namespace JSXElements {
      export interface IonFabListAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          activated?: boolean
      }
  }
}

import { FabButton as IonFabButton } from './components/fab/fab';

interface HTMLIonFabButtonElement extends IonFabButton, HTMLElement {
}
declare var HTMLIonFabButtonElement: {
  prototype: HTMLIonFabButtonElement;
  new (): HTMLIonFabButtonElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-fab-button": HTMLIonFabButtonElement;
  }
  interface ElementTagNameMap {
      "ion-fab-button": HTMLIonFabButtonElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-fab-button": JSXElements.IonFabButtonAttributes;
      }
  }
  namespace JSXElements {
      export interface IonFabButtonAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          href?: string,
          activated?: boolean,
          toggleActive?: any,
          show?: boolean,
          disabled?: boolean
      }
  }
}

import { Footer as IonFooter } from './components/footer/footer';

interface HTMLIonFooterElement extends IonFooter, HTMLElement {
}
declare var HTMLIonFooterElement: {
  prototype: HTMLIonFooterElement;
  new (): HTMLIonFooterElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-footer": HTMLIonFooterElement;
  }
  interface ElementTagNameMap {
      "ion-footer": HTMLIonFooterElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-footer": JSXElements.IonFooterAttributes;
      }
  }
  namespace JSXElements {
      export interface IonFooterAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { GestureController as IonGestureController } from './components/gesture-controller/gesture-controller';

interface HTMLIonGestureControllerElement extends IonGestureController, HTMLElement {
}
declare var HTMLIonGestureControllerElement: {
  prototype: HTMLIonGestureControllerElement;
  new (): HTMLIonGestureControllerElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-gesture-controller": HTMLIonGestureControllerElement;
  }
  interface ElementTagNameMap {
      "ion-gesture-controller": HTMLIonGestureControllerElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-gesture-controller": JSXElements.IonGestureControllerAttributes;
      }
  }
  namespace JSXElements {
      export interface IonGestureControllerAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { Gesture as IonGesture } from './components/gesture/gesture';

interface HTMLIonGestureElement extends IonGesture, HTMLElement {
}
declare var HTMLIonGestureElement: {
  prototype: HTMLIonGestureElement;
  new (): HTMLIonGestureElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-gesture": HTMLIonGestureElement;
  }
  interface ElementTagNameMap {
      "ion-gesture": HTMLIonGestureElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-gesture": JSXElements.IonGestureAttributes;
      }
  }
  namespace JSXElements {
      export interface IonGestureAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          enabled?: boolean,
          attachTo?: string,
          autoBlockAll?: boolean,
          block?: string,
          disableScroll?: boolean,
          direction?: string,
          gestureName?: string,
          gesturePriority?: number,
          maxAngle?: number,
          threshold?: number,
          type?: string,
          canStart?: any,
          onWillStart?: any,
          onStart?: any,
          onMove?: any,
          onEnd?: any,
          onPress?: any,
          notCaptured?: any
      }
  }
}

import { Col as IonCol } from './components/grid/col';

interface HTMLIonColElement extends IonCol, HTMLElement {
}
declare var HTMLIonColElement: {
  prototype: HTMLIonColElement;
  new (): HTMLIonColElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-col": HTMLIonColElement;
  }
  interface ElementTagNameMap {
      "ion-col": HTMLIonColElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-col": JSXElements.IonColAttributes;
      }
  }
  namespace JSXElements {
      export interface IonColAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { Grid as IonGrid } from './components/grid/grid';

interface HTMLIonGridElement extends IonGrid, HTMLElement {
}
declare var HTMLIonGridElement: {
  prototype: HTMLIonGridElement;
  new (): HTMLIonGridElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-grid": HTMLIonGridElement;
  }
  interface ElementTagNameMap {
      "ion-grid": HTMLIonGridElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-grid": JSXElements.IonGridAttributes;
      }
  }
  namespace JSXElements {
      export interface IonGridAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { Row as IonRow } from './components/grid/row';

interface HTMLIonRowElement extends IonRow, HTMLElement {
}
declare var HTMLIonRowElement: {
  prototype: HTMLIonRowElement;
  new (): HTMLIonRowElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-row": HTMLIonRowElement;
  }
  interface ElementTagNameMap {
      "ion-row": HTMLIonRowElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-row": JSXElements.IonRowAttributes;
      }
  }
  namespace JSXElements {
      export interface IonRowAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { Header as IonHeader } from './components/header/header';

interface HTMLIonHeaderElement extends IonHeader, HTMLElement {
}
declare var HTMLIonHeaderElement: {
  prototype: HTMLIonHeaderElement;
  new (): HTMLIonHeaderElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-header": HTMLIonHeaderElement;
  }
  interface ElementTagNameMap {
      "ion-header": HTMLIonHeaderElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-header": JSXElements.IonHeaderAttributes;
      }
  }
  namespace JSXElements {
      export interface IonHeaderAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { InfiniteScrollContent as IonInfiniteScrollContent } from './components/infinite-scroll/infinite-scroll-content';

interface HTMLIonInfiniteScrollContentElement extends IonInfiniteScrollContent, HTMLElement {
}
declare var HTMLIonInfiniteScrollContentElement: {
  prototype: HTMLIonInfiniteScrollContentElement;
  new (): HTMLIonInfiniteScrollContentElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-infinite-scroll-content": HTMLIonInfiniteScrollContentElement;
  }
  interface ElementTagNameMap {
      "ion-infinite-scroll-content": HTMLIonInfiniteScrollContentElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-infinite-scroll-content": JSXElements.IonInfiniteScrollContentAttributes;
      }
  }
  namespace JSXElements {
      export interface IonInfiniteScrollContentAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          loadingSpinner?: string,
          loadingText?: string
      }
  }
}

import { InfiniteScroll as IonInfiniteScroll } from './components/infinite-scroll/infinite-scroll';

interface HTMLIonInfiniteScrollElement extends IonInfiniteScroll, HTMLElement {
}
declare var HTMLIonInfiniteScrollElement: {
  prototype: HTMLIonInfiniteScrollElement;
  new (): HTMLIonInfiniteScrollElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-infinite-scroll": HTMLIonInfiniteScrollElement;
  }
  interface ElementTagNameMap {
      "ion-infinite-scroll": HTMLIonInfiniteScrollElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-infinite-scroll": JSXElements.IonInfiniteScrollAttributes;
      }
  }
  namespace JSXElements {
      export interface IonInfiniteScrollAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          complete?: any,
          threshold?: string,
          enabled?: boolean,
          position?: string
      }
  }
}

import { Input as IonInput } from './components/input/input';

interface HTMLIonInputElement extends IonInput, HTMLElement {
}
declare var HTMLIonInputElement: {
  prototype: HTMLIonInputElement;
  new (): HTMLIonInputElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-input": HTMLIonInputElement;
  }
  interface ElementTagNameMap {
      "ion-input": HTMLIonInputElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-input": JSXElements.IonInputAttributes;
      }
  }
  namespace JSXElements {
      export interface IonInputAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          accept?: string,
          autocapitalize?: string,
          autocomplete?: string,
          autocorrect?: string,
          autofocus?: boolean,
          checked?: boolean,
          clearInput?: boolean,
          clearOnEdit?: boolean,
          disabled?: boolean,
          inputmode?: string,
          max?: string,
          maxlength?: number,
          min?: string,
          minlength?: number,
          multiple?: boolean,
          name?: string,
          pattern?: string,
          placeholder?: string,
          readonly?: boolean,
          required?: boolean,
          results?: number,
          spellcheck?: boolean,
          step?: string,
          size?: number,
          type?: string,
          value?: string
      }
  }
}

import { Textarea as IonTextarea } from './components/input/textarea';

interface HTMLIonTextareaElement extends IonTextarea, HTMLElement {
}
declare var HTMLIonTextareaElement: {
  prototype: HTMLIonTextareaElement;
  new (): HTMLIonTextareaElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-textarea": HTMLIonTextareaElement;
  }
  interface ElementTagNameMap {
      "ion-textarea": HTMLIonTextareaElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-textarea": JSXElements.IonTextareaAttributes;
      }
  }
  namespace JSXElements {
      export interface IonTextareaAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          autocapitalize?: string,
          autocomplete?: string,
          autofocus?: boolean,
          clearOnEdit?: boolean,
          disabled?: boolean,
          maxlength?: number,
          minlength?: number,
          name?: string,
          placeholder?: string,
          readonly?: boolean,
          required?: boolean,
          spellcheck?: boolean,
          cols?: number,
          rows?: number,
          wrap?: string,
          value?: string
      }
  }
}

import { ItemDivider as IonItemDivider } from './components/item-divider/item-divider';

interface HTMLIonItemDividerElement extends IonItemDivider, HTMLElement {
}
declare var HTMLIonItemDividerElement: {
  prototype: HTMLIonItemDividerElement;
  new (): HTMLIonItemDividerElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-item-divider": HTMLIonItemDividerElement;
  }
  interface ElementTagNameMap {
      "ion-item-divider": HTMLIonItemDividerElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-item-divider": JSXElements.IonItemDividerAttributes;
      }
  }
  namespace JSXElements {
      export interface IonItemDividerAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { ItemOption as IonItemOption } from './components/item-sliding/item-option';

interface HTMLIonItemOptionElement extends IonItemOption, HTMLElement {
}
declare var HTMLIonItemOptionElement: {
  prototype: HTMLIonItemOptionElement;
  new (): HTMLIonItemOptionElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-item-option": HTMLIonItemOptionElement;
  }
  interface ElementTagNameMap {
      "ion-item-option": HTMLIonItemOptionElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-item-option": JSXElements.IonItemOptionAttributes;
      }
  }
  namespace JSXElements {
      export interface IonItemOptionAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          href?: string,
          disabled?: boolean
      }
  }
}

import { ItemOptions as IonItemOptions } from './components/item-sliding/item-options';

interface HTMLIonItemOptionsElement extends IonItemOptions, HTMLElement {
}
declare var HTMLIonItemOptionsElement: {
  prototype: HTMLIonItemOptionsElement;
  new (): HTMLIonItemOptionsElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-item-options": HTMLIonItemOptionsElement;
  }
  interface ElementTagNameMap {
      "ion-item-options": HTMLIonItemOptionsElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-item-options": JSXElements.IonItemOptionsAttributes;
      }
  }
  namespace JSXElements {
      export interface IonItemOptionsAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          isRightSide?: any,
          width?: any,
          side?: string
      }
  }
}

import { ItemSliding as IonItemSliding } from './components/item-sliding/item-sliding';

interface HTMLIonItemSlidingElement extends IonItemSliding, HTMLElement {
}
declare var HTMLIonItemSlidingElement: {
  prototype: HTMLIonItemSlidingElement;
  new (): HTMLIonItemSlidingElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-item-sliding": HTMLIonItemSlidingElement;
  }
  interface ElementTagNameMap {
      "ion-item-sliding": HTMLIonItemSlidingElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-item-sliding": JSXElements.IonItemSlidingAttributes;
      }
  }
  namespace JSXElements {
      export interface IonItemSlidingAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          close?: any
      }
  }
}

import { Item as IonItem } from './components/item/item';

interface HTMLIonItemElement extends IonItem, HTMLElement {
}
declare var HTMLIonItemElement: {
  prototype: HTMLIonItemElement;
  new (): HTMLIonItemElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-item": HTMLIonItemElement;
  }
  interface ElementTagNameMap {
      "ion-item": HTMLIonItemElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-item": JSXElements.IonItemAttributes;
      }
  }
  namespace JSXElements {
      export interface IonItemAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          getLabelText?: any,
          href?: string
      }
  }
}

import { IonKeyboardController as IonKeyboardController } from './components/keyboard-controller/keyboard-controller';

interface HTMLIonKeyboardControllerElement extends IonKeyboardController, HTMLElement {
}
declare var HTMLIonKeyboardControllerElement: {
  prototype: HTMLIonKeyboardControllerElement;
  new (): HTMLIonKeyboardControllerElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-keyboard-controller": HTMLIonKeyboardControllerElement;
  }
  interface ElementTagNameMap {
      "ion-keyboard-controller": HTMLIonKeyboardControllerElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-keyboard-controller": JSXElements.IonKeyboardControllerAttributes;
      }
  }
  namespace JSXElements {
      export interface IonKeyboardControllerAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { Label as IonLabel } from './components/label/label';

interface HTMLIonLabelElement extends IonLabel, HTMLElement {
}
declare var HTMLIonLabelElement: {
  prototype: HTMLIonLabelElement;
  new (): HTMLIonLabelElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-label": HTMLIonLabelElement;
  }
  interface ElementTagNameMap {
      "ion-label": HTMLIonLabelElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-label": JSXElements.IonLabelAttributes;
      }
  }
  namespace JSXElements {
      export interface IonLabelAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          getText?: any,
          fixed?: boolean,
          floating?: boolean,
          stacked?: boolean
      }
  }
}

import { ListHeader as IonListHeader } from './components/list-header/list-header';

interface HTMLIonListHeaderElement extends IonListHeader, HTMLElement {
}
declare var HTMLIonListHeaderElement: {
  prototype: HTMLIonListHeaderElement;
  new (): HTMLIonListHeaderElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-list-header": HTMLIonListHeaderElement;
  }
  interface ElementTagNameMap {
      "ion-list-header": HTMLIonListHeaderElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-list-header": JSXElements.IonListHeaderAttributes;
      }
  }
  namespace JSXElements {
      export interface IonListHeaderAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { List as IonList } from './components/list/list';

interface HTMLIonListElement extends IonList, HTMLElement {
}
declare var HTMLIonListElement: {
  prototype: HTMLIonListElement;
  new (): HTMLIonListElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-list": HTMLIonListElement;
  }
  interface ElementTagNameMap {
      "ion-list": HTMLIonListElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-list": JSXElements.IonListAttributes;
      }
  }
  namespace JSXElements {
      export interface IonListAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          getOpenedItem?: any,
          setOpenedItem?: any,
          closeSlidingItems?: any
      }
  }
}

import { LoadingController as IonLoadingController } from './components/loading-controller/loading-controller';

interface HTMLIonLoadingControllerElement extends IonLoadingController, HTMLElement {
}
declare var HTMLIonLoadingControllerElement: {
  prototype: HTMLIonLoadingControllerElement;
  new (): HTMLIonLoadingControllerElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-loading-controller": HTMLIonLoadingControllerElement;
  }
  interface ElementTagNameMap {
      "ion-loading-controller": HTMLIonLoadingControllerElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-loading-controller": JSXElements.IonLoadingControllerAttributes;
      }
  }
  namespace JSXElements {
      export interface IonLoadingControllerAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          create?: any
      }
  }
}

import { Loading as IonLoading } from './components/loading/loading';

interface HTMLIonLoadingElement extends IonLoading, HTMLElement {
}
declare var HTMLIonLoadingElement: {
  prototype: HTMLIonLoadingElement;
  new (): HTMLIonLoadingElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-loading": HTMLIonLoadingElement;
  }
  interface ElementTagNameMap {
      "ion-loading": HTMLIonLoadingElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-loading": JSXElements.IonLoadingAttributes;
      }
  }
  namespace JSXElements {
      export interface IonLoadingAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          animationCtrl?: any,
          cssClass?: string,
          content?: string,
          dismissOnPageChange?: boolean,
          duration?: number,
          enterAnimation?: any,
          exitAnimation?: any,
          loadingId?: string,
          showBackdrop?: boolean
      }
  }
}

import { MenuController as IonMenuController } from './components/menu/menu-controller';

interface HTMLIonMenuControllerElement extends IonMenuController, HTMLElement {
}
declare var HTMLIonMenuControllerElement: {
  prototype: HTMLIonMenuControllerElement;
  new (): HTMLIonMenuControllerElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-menu-controller": HTMLIonMenuControllerElement;
  }
  interface ElementTagNameMap {
      "ion-menu-controller": HTMLIonMenuControllerElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-menu-controller": JSXElements.IonMenuControllerAttributes;
      }
  }
  namespace JSXElements {
      export interface IonMenuControllerAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          open?: any,
          close?: any,
          toggle?: any,
          enable?: any,
          swipeEnable?: any,
          isOpen?: any,
          isEnabled?: any,
          get?: any,
          getOpen?: any,
          getMenus?: any,
          isAnimating?: any,
          _register?: any,
          _unregister?: any,
          _setActiveMenu?: any,
          createAnimation?: any,
          animationCtrl?: any
      }
  }
}

import { Menu as IonMenu } from './components/menu/menu';

interface HTMLIonMenuElement extends IonMenu, HTMLElement {
}
declare var HTMLIonMenuElement: {
  prototype: HTMLIonMenuElement;
  new (): HTMLIonMenuElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-menu": HTMLIonMenuElement;
  }
  interface ElementTagNameMap {
      "ion-menu": HTMLIonMenuElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-menu": JSXElements.IonMenuAttributes;
      }
  }
  namespace JSXElements {
      export interface IonMenuAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          isOpen?: any,
          setOpen?: any,
          open?: any,
          close?: any,
          toggle?: any,
          lazyMenuCtrl?: any,
          content?: string,
          menuId?: string,
          type?: string,
          enabled?: boolean,
          side?: string,
          swipeEnabled?: boolean,
          persistent?: boolean,
          maxEdgeStart?: number
      }
  }
}

import { ModalController as IonModalController } from './components/modal-controller/modal-controller';

interface HTMLIonModalControllerElement extends IonModalController, HTMLElement {
}
declare var HTMLIonModalControllerElement: {
  prototype: HTMLIonModalControllerElement;
  new (): HTMLIonModalControllerElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-modal-controller": HTMLIonModalControllerElement;
  }
  interface ElementTagNameMap {
      "ion-modal-controller": HTMLIonModalControllerElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-modal-controller": JSXElements.IonModalControllerAttributes;
      }
  }
  namespace JSXElements {
      export interface IonModalControllerAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          create?: any
      }
  }
}

import { Modal as IonModal } from './components/modal/modal';

interface HTMLIonModalElement extends IonModal, HTMLElement {
}
declare var HTMLIonModalElement: {
  prototype: HTMLIonModalElement;
  new (): HTMLIonModalElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-modal": HTMLIonModalElement;
  }
  interface ElementTagNameMap {
      "ion-modal": HTMLIonModalElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-modal": JSXElements.IonModalAttributes;
      }
  }
  namespace JSXElements {
      export interface IonModalAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          animationCtrl?: any,
          component?: string,
          componentProps?: any,
          cssClass?: string,
          enableBackdropDismiss?: boolean,
          enterAnimation?: any,
          exitAnimation?: any,
          modalId?: string,
          showBackdrop?: boolean
      }
  }
}

import { NavControllerImpl as IonNavController } from './components/nav-controller/nav-controller';

interface HTMLIonNavControllerElement extends IonNavController, HTMLElement {
}
declare var HTMLIonNavControllerElement: {
  prototype: HTMLIonNavControllerElement;
  new (): HTMLIonNavControllerElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-nav-controller": HTMLIonNavControllerElement;
  }
  interface ElementTagNameMap {
      "ion-nav-controller": HTMLIonNavControllerElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-nav-controller": JSXElements.IonNavControllerAttributes;
      }
  }
  namespace JSXElements {
      export interface IonNavControllerAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          push?: any,
          pop?: any,
          setRoot?: any,
          insert?: any,
          insertPages?: any,
          popToRoot?: any,
          popTo?: any,
          removeIndex?: any,
          removeView?: any,
          setPages?: any,
          delegate?: any,
          animationCtrl?: any
      }
  }
}

import { StencilNavDelegate as StencilIonNavDelegate } from './components/nav-controller/stencil-nav-delegate';

interface HTMLStencilIonNavDelegateElement extends StencilIonNavDelegate, HTMLElement {
}
declare var HTMLStencilIonNavDelegateElement: {
  prototype: HTMLStencilIonNavDelegateElement;
  new (): HTMLStencilIonNavDelegateElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "stencil-ion-nav-delegate": HTMLStencilIonNavDelegateElement;
  }
  interface ElementTagNameMap {
      "stencil-ion-nav-delegate": HTMLStencilIonNavDelegateElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "stencil-ion-nav-delegate": JSXElements.StencilIonNavDelegateAttributes;
      }
  }
  namespace JSXElements {
      export interface StencilIonNavDelegateAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          attachViewToDom?: any,
          removeViewFromDom?: any
      }
  }
}

import { IonNav as IonNav } from './components/nav/nav';

interface HTMLIonNavElement extends IonNav, HTMLElement {
}
declare var HTMLIonNavElement: {
  prototype: HTMLIonNavElement;
  new (): HTMLIonNavElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-nav": HTMLIonNavElement;
  }
  interface ElementTagNameMap {
      "ion-nav": HTMLIonNavElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-nav": JSXElements.IonNavAttributes;
      }
  }
  namespace JSXElements {
      export interface IonNavAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          push?: any,
          pop?: any,
          setRoot?: any,
          insert?: any,
          insertPages?: any,
          popToRoot?: any,
          popTo?: any,
          removeIndex?: any,
          removeView?: any,
          setPages?: any,
          getActive?: any,
          getPrevious?: any,
          canGoBack?: any,
          canSwipeBack?: any,
          getFirstView?: any,
          root?: any,
          delegate?: any
      }
  }
}

import { PageOne as PageOne } from './components/nav/page-one';

interface HTMLPageOneElement extends PageOne, HTMLElement {
}
declare var HTMLPageOneElement: {
  prototype: HTMLPageOneElement;
  new (): HTMLPageOneElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "page-one": HTMLPageOneElement;
  }
  interface ElementTagNameMap {
      "page-one": HTMLPageOneElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "page-one": JSXElements.PageOneAttributes;
      }
  }
  namespace JSXElements {
      export interface PageOneAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { PageThree as PageThree } from './components/nav/page-three';

interface HTMLPageThreeElement extends PageThree, HTMLElement {
}
declare var HTMLPageThreeElement: {
  prototype: HTMLPageThreeElement;
  new (): HTMLPageThreeElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "page-three": HTMLPageThreeElement;
  }
  interface ElementTagNameMap {
      "page-three": HTMLPageThreeElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "page-three": JSXElements.PageThreeAttributes;
      }
  }
  namespace JSXElements {
      export interface PageThreeAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { PageTwo as PageTwo } from './components/nav/page-two';

interface HTMLPageTwoElement extends PageTwo, HTMLElement {
}
declare var HTMLPageTwoElement: {
  prototype: HTMLPageTwoElement;
  new (): HTMLPageTwoElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "page-two": HTMLPageTwoElement;
  }
  interface ElementTagNameMap {
      "page-two": HTMLPageTwoElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "page-two": JSXElements.PageTwoAttributes;
      }
  }
  namespace JSXElements {
      export interface PageTwoAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { Note as IonNote } from './components/note/note';

interface HTMLIonNoteElement extends IonNote, HTMLElement {
}
declare var HTMLIonNoteElement: {
  prototype: HTMLIonNoteElement;
  new (): HTMLIonNoteElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-note": HTMLIonNoteElement;
  }
  interface ElementTagNameMap {
      "ion-note": HTMLIonNoteElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-note": JSXElements.IonNoteAttributes;
      }
  }
  namespace JSXElements {
      export interface IonNoteAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { Page as IonPage } from './components/page/page';

interface HTMLIonPageElement extends IonPage, HTMLElement {
}
declare var HTMLIonPageElement: {
  prototype: HTMLIonPageElement;
  new (): HTMLIonPageElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-page": HTMLIonPageElement;
  }
  interface ElementTagNameMap {
      "ion-page": HTMLIonPageElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-page": JSXElements.IonPageAttributes;
      }
  }
  namespace JSXElements {
      export interface IonPageAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { PickerController as IonPickerController } from './components/picker-controller/picker-controller';

interface HTMLIonPickerControllerElement extends IonPickerController, HTMLElement {
}
declare var HTMLIonPickerControllerElement: {
  prototype: HTMLIonPickerControllerElement;
  new (): HTMLIonPickerControllerElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-picker-controller": HTMLIonPickerControllerElement;
  }
  interface ElementTagNameMap {
      "ion-picker-controller": HTMLIonPickerControllerElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-picker-controller": JSXElements.IonPickerControllerAttributes;
      }
  }
  namespace JSXElements {
      export interface IonPickerControllerAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          create?: any
      }
  }
}

import { PickerColumnCmp as IonPickerColumn } from './components/picker/picker-column';

interface HTMLIonPickerColumnElement extends IonPickerColumn, HTMLElement {
}
declare var HTMLIonPickerColumnElement: {
  prototype: HTMLIonPickerColumnElement;
  new (): HTMLIonPickerColumnElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-picker-column": HTMLIonPickerColumnElement;
  }
  interface ElementTagNameMap {
      "ion-picker-column": HTMLIonPickerColumnElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-picker-column": JSXElements.IonPickerColumnAttributes;
      }
  }
  namespace JSXElements {
      export interface IonPickerColumnAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          col?: any
      }
  }
}

import { Picker as IonPicker } from './components/picker/picker';

interface HTMLIonPickerElement extends IonPicker, HTMLElement {
}
declare var HTMLIonPickerElement: {
  prototype: HTMLIonPickerElement;
  new (): HTMLIonPickerElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-picker": HTMLIonPickerElement;
  }
  interface ElementTagNameMap {
      "ion-picker": HTMLIonPickerElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-picker": JSXElements.IonPickerAttributes;
      }
  }
  namespace JSXElements {
      export interface IonPickerAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          addButton?: any,
          addColumn?: any,
          getColumn?: any,
          getColumns?: any,
          animationCtrl?: any,
          cssClass?: string,
          content?: string,
          dismissOnPageChange?: boolean,
          duration?: number,
          enterAnimation?: any,
          exitAnimation?: any,
          pickerId?: string,
          showBackdrop?: boolean,
          enableBackdropDismiss?: boolean,
          buttons?: any,
          columns?: any
      }
  }
}

import { PopoverController as IonPopoverController } from './components/popover-controller/popover-controller';

interface HTMLIonPopoverControllerElement extends IonPopoverController, HTMLElement {
}
declare var HTMLIonPopoverControllerElement: {
  prototype: HTMLIonPopoverControllerElement;
  new (): HTMLIonPopoverControllerElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-popover-controller": HTMLIonPopoverControllerElement;
  }
  interface ElementTagNameMap {
      "ion-popover-controller": HTMLIonPopoverControllerElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-popover-controller": JSXElements.IonPopoverControllerAttributes;
      }
  }
  namespace JSXElements {
      export interface IonPopoverControllerAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          create?: any
      }
  }
}

import { Popover as IonPopover } from './components/popover/popover';

interface HTMLIonPopoverElement extends IonPopover, HTMLElement {
}
declare var HTMLIonPopoverElement: {
  prototype: HTMLIonPopoverElement;
  new (): HTMLIonPopoverElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-popover": HTMLIonPopoverElement;
  }
  interface ElementTagNameMap {
      "ion-popover": HTMLIonPopoverElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-popover": JSXElements.IonPopoverAttributes;
      }
  }
  namespace JSXElements {
      export interface IonPopoverAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          animationCtrl?: any,
          component?: string,
          componentProps?: any,
          cssClass?: string,
          enableBackdropDismiss?: boolean,
          enterAnimation?: any,
          exitAnimation?: any,
          ev?: any,
          popoverId?: string,
          showBackdrop?: boolean
      }
  }
}

import { RadioGroup as IonRadioGroup } from './components/radio/radio-group';

interface HTMLIonRadioGroupElement extends IonRadioGroup, HTMLElement {
}
declare var HTMLIonRadioGroupElement: {
  prototype: HTMLIonRadioGroupElement;
  new (): HTMLIonRadioGroupElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-radio-group": HTMLIonRadioGroupElement;
  }
  interface ElementTagNameMap {
      "ion-radio-group": HTMLIonRadioGroupElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-radio-group": JSXElements.IonRadioGroupAttributes;
      }
  }
  namespace JSXElements {
      export interface IonRadioGroupAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          allowEmptySelection?: boolean,
          disabled?: boolean,
          value?: string
      }
  }
}

import { Radio as IonRadio } from './components/radio/radio';

interface HTMLIonRadioElement extends IonRadio, HTMLElement {
}
declare var HTMLIonRadioElement: {
  prototype: HTMLIonRadioElement;
  new (): HTMLIonRadioElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-radio": HTMLIonRadioElement;
  }
  interface ElementTagNameMap {
      "ion-radio": HTMLIonRadioElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-radio": JSXElements.IonRadioAttributes;
      }
  }
  namespace JSXElements {
      export interface IonRadioAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          checked?: boolean,
          disabled?: boolean,
          value?: string
      }
  }
}

import { RangeKnob as IonRangeKnob } from './components/range/range-knob';

interface HTMLIonRangeKnobElement extends IonRangeKnob, HTMLElement {
}
declare var HTMLIonRangeKnobElement: {
  prototype: HTMLIonRangeKnobElement;
  new (): HTMLIonRangeKnobElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-range-knob": HTMLIonRangeKnobElement;
  }
  interface ElementTagNameMap {
      "ion-range-knob": HTMLIonRangeKnobElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-range-knob": JSXElements.IonRangeKnobAttributes;
      }
  }
  namespace JSXElements {
      export interface IonRangeKnobAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          pressed?: boolean,
          pin?: boolean,
          min?: number,
          max?: number,
          val?: number,
          disabled?: boolean,
          labelId?: string,
          knob?: string,
          ratio?: number
      }
  }
}

import { Range as IonRange } from './components/range/range';

interface HTMLIonRangeElement extends IonRange, HTMLElement {
}
declare var HTMLIonRangeElement: {
  prototype: HTMLIonRangeElement;
  new (): HTMLIonRangeElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-range": HTMLIonRangeElement;
  }
  interface ElementTagNameMap {
      "ion-range": HTMLIonRangeElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-range": JSXElements.IonRangeAttributes;
      }
  }
  namespace JSXElements {
      export interface IonRangeAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          ratio?: any,
          ratioUpper?: any,
          value?: any,
          disabled?: boolean,
          min?: number,
          max?: number,
          steps?: number,
          dualKnobs?: boolean,
          pin?: boolean,
          snaps?: boolean,
          debounce?: number
      }
  }
}

import { ReorderGroup as IonReorderGroup } from './components/reorder/reorder-group';

interface HTMLIonReorderGroupElement extends IonReorderGroup, HTMLElement {
}
declare var HTMLIonReorderGroupElement: {
  prototype: HTMLIonReorderGroupElement;
  new (): HTMLIonReorderGroupElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-reorder-group": HTMLIonReorderGroupElement;
  }
  interface ElementTagNameMap {
      "ion-reorder-group": HTMLIonReorderGroupElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-reorder-group": JSXElements.IonReorderGroupAttributes;
      }
  }
  namespace JSXElements {
      export interface IonReorderGroupAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          enabled?: boolean
      }
  }
}

import { ItemReorder as IonReorder } from './components/reorder/reorder';

interface HTMLIonReorderElement extends IonReorder, HTMLElement {
}
declare var HTMLIonReorderElement: {
  prototype: HTMLIonReorderElement;
  new (): HTMLIonReorderElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-reorder": HTMLIonReorderElement;
  }
  interface ElementTagNameMap {
      "ion-reorder": HTMLIonReorderElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-reorder": JSXElements.IonReorderAttributes;
      }
  }
  namespace JSXElements {
      export interface IonReorderAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { RouteLink as IonRouteLink } from './components/router/route-link';

interface HTMLIonRouteLinkElement extends IonRouteLink, HTMLElement {
}
declare var HTMLIonRouteLinkElement: {
  prototype: HTMLIonRouteLinkElement;
  new (): HTMLIonRouteLinkElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-route-link": HTMLIonRouteLinkElement;
  }
  interface ElementTagNameMap {
      "ion-route-link": HTMLIonRouteLinkElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-route-link": JSXElements.IonRouteLinkAttributes;
      }
  }
  namespace JSXElements {
      export interface IonRouteLinkAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          url?: string,
          router?: any
      }
  }
}

import { Route as IonRoute } from './components/router/route';

interface HTMLIonRouteElement extends IonRoute, HTMLElement {
}
declare var HTMLIonRouteElement: {
  prototype: HTMLIonRouteElement;
  new (): HTMLIonRouteElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-route": HTMLIonRouteElement;
  }
  interface ElementTagNameMap {
      "ion-route": HTMLIonRouteElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-route": JSXElements.IonRouteAttributes;
      }
  }
  namespace JSXElements {
      export interface IonRouteAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          url?: string,
          component?: string,
          componentProps?: any,
          router?: any
      }
  }
}

import { Router as IonRouter } from './components/router/router';

interface HTMLIonRouterElement extends IonRouter, HTMLElement {
}
declare var HTMLIonRouterElement: {
  prototype: HTMLIonRouterElement;
  new (): HTMLIonRouterElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-router": HTMLIonRouterElement;
  }
  interface ElementTagNameMap {
      "ion-router": HTMLIonRouterElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-router": JSXElements.IonRouterAttributes;
      }
  }
  namespace JSXElements {
      export interface IonRouterAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          root?: string,
          match?: any
      }
  }
}

import { Scroll as IonScroll } from './components/scroll/scroll';

interface HTMLIonScrollElement extends IonScroll, HTMLElement {
}
declare var HTMLIonScrollElement: {
  prototype: HTMLIonScrollElement;
  new (): HTMLIonScrollElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-scroll": HTMLIonScrollElement;
  }
  interface ElementTagNameMap {
      "ion-scroll": HTMLIonScrollElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-scroll": JSXElements.IonScrollAttributes;
      }
  }
  namespace JSXElements {
      export interface IonScrollAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          scrollToTop?: any,
          scrollToBottom?: any,
          scrollToPoint?: any,
          enabled?: boolean,
          jsScroll?: boolean,
          onionScrollStart?: any,
          onionScroll?: any,
          onionScrollEnd?: any
      }
  }
}

import { Searchbar as IonSearchbar } from './components/searchbar/searchbar';

interface HTMLIonSearchbarElement extends IonSearchbar, HTMLElement {
}
declare var HTMLIonSearchbarElement: {
  prototype: HTMLIonSearchbarElement;
  new (): HTMLIonSearchbarElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-searchbar": HTMLIonSearchbarElement;
  }
  interface ElementTagNameMap {
      "ion-searchbar": HTMLIonSearchbarElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-searchbar": JSXElements.IonSearchbarAttributes;
      }
  }
  namespace JSXElements {
      export interface IonSearchbarAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          animated?: boolean,
          autocomplete?: string,
          autocorrect?: string,
          cancelButtonText?: string,
          debounce?: number,
          placeholder?: string,
          showCancelButton?: boolean,
          spellcheck?: boolean,
          type?: string,
          value?: string
      }
  }
}

import { SegmentButton as IonSegmentButton } from './components/segment-button/segment-button';

interface HTMLIonSegmentButtonElement extends IonSegmentButton, HTMLElement {
}
declare var HTMLIonSegmentButtonElement: {
  prototype: HTMLIonSegmentButtonElement;
  new (): HTMLIonSegmentButtonElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-segment-button": HTMLIonSegmentButtonElement;
  }
  interface ElementTagNameMap {
      "ion-segment-button": HTMLIonSegmentButtonElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-segment-button": JSXElements.IonSegmentButtonAttributes;
      }
  }
  namespace JSXElements {
      export interface IonSegmentButtonAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          checked?: boolean,
          disabled?: boolean,
          value?: string
      }
  }
}

import { Segment as IonSegment } from './components/segment/segment';

interface HTMLIonSegmentElement extends IonSegment, HTMLElement {
}
declare var HTMLIonSegmentElement: {
  prototype: HTMLIonSegmentElement;
  new (): HTMLIonSegmentElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-segment": HTMLIonSegmentElement;
  }
  interface ElementTagNameMap {
      "ion-segment": HTMLIonSegmentElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-segment": JSXElements.IonSegmentAttributes;
      }
  }
  namespace JSXElements {
      export interface IonSegmentAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          disabled?: boolean,
          value?: string
      }
  }
}

import { SelectOption as IonSelectOption } from './components/select-option/select-option';

interface HTMLIonSelectOptionElement extends IonSelectOption, HTMLElement {
}
declare var HTMLIonSelectOptionElement: {
  prototype: HTMLIonSelectOptionElement;
  new (): HTMLIonSelectOptionElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-select-option": HTMLIonSelectOptionElement;
  }
  interface ElementTagNameMap {
      "ion-select-option": HTMLIonSelectOptionElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-select-option": JSXElements.IonSelectOptionAttributes;
      }
  }
  namespace JSXElements {
      export interface IonSelectOptionAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          getText?: any,
          disabled?: boolean,
          selected?: boolean,
          value?: string
      }
  }
}

import { SelectPopover as IonSelectPopover } from './components/select/select-popover';

interface HTMLIonSelectPopoverElement extends IonSelectPopover, HTMLElement {
}
declare var HTMLIonSelectPopoverElement: {
  prototype: HTMLIonSelectPopoverElement;
  new (): HTMLIonSelectPopoverElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-select-popover": HTMLIonSelectPopoverElement;
  }
  interface ElementTagNameMap {
      "ion-select-popover": HTMLIonSelectPopoverElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-select-popover": JSXElements.IonSelectPopoverAttributes;
      }
  }
  namespace JSXElements {
      export interface IonSelectPopoverAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          options?: any,
          value?: string
      }
  }
}

import { Select as IonSelect } from './components/select/select';

interface HTMLIonSelectElement extends IonSelect, HTMLElement {
}
declare var HTMLIonSelectElement: {
  prototype: HTMLIonSelectElement;
  new (): HTMLIonSelectElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-select": HTMLIonSelectElement;
  }
  interface ElementTagNameMap {
      "ion-select": HTMLIonSelectElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-select": JSXElements.IonSelectAttributes;
      }
  }
  namespace JSXElements {
      export interface IonSelectAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          actionSheetCtrl?: any,
          alertCtrl?: any,
          popoverCtrl?: any,
          disabled?: boolean,
          cancelText?: string,
          okText?: string,
          placeholder?: string,
          selectOptions?: any,
          interface?: string,
          selectedText?: string,
          multiple?: boolean,
          value?: any
      }
  }
}

import { SkeletonText as IonSkeletonText } from './components/skeleton-text/skeleton-text';

interface HTMLIonSkeletonTextElement extends IonSkeletonText, HTMLElement {
}
declare var HTMLIonSkeletonTextElement: {
  prototype: HTMLIonSkeletonTextElement;
  new (): HTMLIonSkeletonTextElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-skeleton-text": HTMLIonSkeletonTextElement;
  }
  interface ElementTagNameMap {
      "ion-skeleton-text": HTMLIonSkeletonTextElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-skeleton-text": JSXElements.IonSkeletonTextAttributes;
      }
  }
  namespace JSXElements {
      export interface IonSkeletonTextAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          width?: string
      }
  }
}

import { Slide as IonSlide } from './components/slides/slide';

interface HTMLIonSlideElement extends IonSlide, HTMLElement {
}
declare var HTMLIonSlideElement: {
  prototype: HTMLIonSlideElement;
  new (): HTMLIonSlideElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-slide": HTMLIonSlideElement;
  }
  interface ElementTagNameMap {
      "ion-slide": HTMLIonSlideElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-slide": JSXElements.IonSlideAttributes;
      }
  }
  namespace JSXElements {
      export interface IonSlideAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { Slides as IonSlides } from './components/slides/slides';

interface HTMLIonSlidesElement extends IonSlides, HTMLElement {
}
declare var HTMLIonSlidesElement: {
  prototype: HTMLIonSlidesElement;
  new (): HTMLIonSlidesElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-slides": HTMLIonSlidesElement;
  }
  interface ElementTagNameMap {
      "ion-slides": HTMLIonSlidesElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-slides": JSXElements.IonSlidesAttributes;
      }
  }
  namespace JSXElements {
      export interface IonSlidesAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          effect?: string,
          autoplay?: number,
          control?: any,
          direction?: string,
          initialSlide?: number,
          loop?: boolean,
          pager?: boolean,
          paginationType?: string,
          parallax?: boolean,
          slidesPerView?: number,
          spaceBetween?: number,
          speed?: number,
          zoom?: boolean,
          keyboardControl?: boolean
      }
  }
}

import { Spinner as IonSpinner } from './components/spinner/spinner';

interface HTMLIonSpinnerElement extends IonSpinner, HTMLElement {
}
declare var HTMLIonSpinnerElement: {
  prototype: HTMLIonSpinnerElement;
  new (): HTMLIonSpinnerElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-spinner": HTMLIonSpinnerElement;
  }
  interface ElementTagNameMap {
      "ion-spinner": HTMLIonSpinnerElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-spinner": JSXElements.IonSpinnerAttributes;
      }
  }
  namespace JSXElements {
      export interface IonSpinnerAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          duration?: number,
          name?: string,
          paused?: boolean
      }
  }
}

import { SplitPane as IonSplitPane } from './components/split-pane/split-pane';

interface HTMLIonSplitPaneElement extends IonSplitPane, HTMLElement {
}
declare var HTMLIonSplitPaneElement: {
  prototype: HTMLIonSplitPaneElement;
  new (): HTMLIonSplitPaneElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-split-pane": HTMLIonSplitPaneElement;
  }
  interface ElementTagNameMap {
      "ion-split-pane": HTMLIonSplitPaneElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-split-pane": JSXElements.IonSplitPaneAttributes;
      }
  }
  namespace JSXElements {
      export interface IonSplitPaneAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          isVisible?: any,
          enabled?: boolean,
          when?: any
      }
  }
}

import { TabBar as IonTabBar } from './components/tabs/tab-bar';

interface HTMLIonTabBarElement extends IonTabBar, HTMLElement {
}
declare var HTMLIonTabBarElement: {
  prototype: HTMLIonTabBarElement;
  new (): HTMLIonTabBarElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-tab-bar": HTMLIonTabBarElement;
  }
  interface ElementTagNameMap {
      "ion-tab-bar": HTMLIonTabBarElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-tab-bar": JSXElements.IonTabBarAttributes;
      }
  }
  namespace JSXElements {
      export interface IonTabBarAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          tabs?: any,
          onTabSelected?: any,
          selectedIndex?: number,
          tabsLayout?: string
      }
  }
}

import { TabButton as IonTabButton } from './components/tabs/tab-button';

interface HTMLIonTabButtonElement extends IonTabButton, HTMLElement {
}
declare var HTMLIonTabButtonElement: {
  prototype: HTMLIonTabButtonElement;
  new (): HTMLIonTabButtonElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-tab-button": HTMLIonTabButtonElement;
  }
  interface ElementTagNameMap {
      "ion-tab-button": HTMLIonTabButtonElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-tab-button": JSXElements.IonTabButtonAttributes;
      }
  }
  namespace JSXElements {
      export interface IonTabButtonAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          tab?: any,
          layout?: string,
          selectedIndex?: number,
          index?: number
      }
  }
}

import { TabHighlight as IonTabHighlight } from './components/tabs/tab-highlight';

interface HTMLIonTabHighlightElement extends IonTabHighlight, HTMLElement {
}
declare var HTMLIonTabHighlightElement: {
  prototype: HTMLIonTabHighlightElement;
  new (): HTMLIonTabHighlightElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-tab-highlight": HTMLIonTabHighlightElement;
  }
  interface ElementTagNameMap {
      "ion-tab-highlight": HTMLIonTabHighlightElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-tab-highlight": JSXElements.IonTabHighlightAttributes;
      }
  }
  namespace JSXElements {
      export interface IonTabHighlightAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { Tab as IonTab } from './components/tabs/tab';

interface HTMLIonTabElement extends IonTab, HTMLElement {
}
declare var HTMLIonTabElement: {
  prototype: HTMLIonTabElement;
  new (): HTMLIonTabElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-tab": HTMLIonTabElement;
  }
  interface ElementTagNameMap {
      "ion-tab": HTMLIonTabElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-tab": JSXElements.IonTabAttributes;
      }
  }
  namespace JSXElements {
      export interface IonTabAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          root?: string,
          rootParams?: any,
          tabTitle?: string,
          tabIcon?: string,
          tabBadge?: string,
          tabBadgeStyle?: string,
          enabled?: boolean,
          shown?: boolean,
          tabsHideOnSubPages?: boolean,
          onSelected?: any
      }
  }
}

import { Tabs as IonTabs } from './components/tabs/tabs';

interface HTMLIonTabsElement extends IonTabs, HTMLElement {
}
declare var HTMLIonTabsElement: {
  prototype: HTMLIonTabsElement;
  new (): HTMLIonTabsElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-tabs": HTMLIonTabsElement;
  }
  interface ElementTagNameMap {
      "ion-tabs": HTMLIonTabsElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-tabs": JSXElements.IonTabsAttributes;
      }
  }
  namespace JSXElements {
      export interface IonTabsAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          tabsLayout?: string,
          tabsPlacement?: string,
          tabsHighlight?: boolean,
          ionChange?: any
      }
  }
}

import { Thumbnail as IonThumbnail } from './components/thumbnail/thumbnail';

interface HTMLIonThumbnailElement extends IonThumbnail, HTMLElement {
}
declare var HTMLIonThumbnailElement: {
  prototype: HTMLIonThumbnailElement;
  new (): HTMLIonThumbnailElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-thumbnail": HTMLIonThumbnailElement;
  }
  interface ElementTagNameMap {
      "ion-thumbnail": HTMLIonThumbnailElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-thumbnail": JSXElements.IonThumbnailAttributes;
      }
  }
  namespace JSXElements {
      export interface IonThumbnailAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { ToolbarTitle as IonTitle } from './components/title/title';

interface HTMLIonTitleElement extends IonTitle, HTMLElement {
}
declare var HTMLIonTitleElement: {
  prototype: HTMLIonTitleElement;
  new (): HTMLIonTitleElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-title": HTMLIonTitleElement;
  }
  interface ElementTagNameMap {
      "ion-title": HTMLIonTitleElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-title": JSXElements.IonTitleAttributes;
      }
  }
  namespace JSXElements {
      export interface IonTitleAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { ToastController as IonToastController } from './components/toast-controller/toast-controller';

interface HTMLIonToastControllerElement extends IonToastController, HTMLElement {
}
declare var HTMLIonToastControllerElement: {
  prototype: HTMLIonToastControllerElement;
  new (): HTMLIonToastControllerElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-toast-controller": HTMLIonToastControllerElement;
  }
  interface ElementTagNameMap {
      "ion-toast-controller": HTMLIonToastControllerElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-toast-controller": JSXElements.IonToastControllerAttributes;
      }
  }
  namespace JSXElements {
      export interface IonToastControllerAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          create?: any
      }
  }
}

import { Toast as IonToast } from './components/toast/toast';

interface HTMLIonToastElement extends IonToast, HTMLElement {
}
declare var HTMLIonToastElement: {
  prototype: HTMLIonToastElement;
  new (): HTMLIonToastElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-toast": HTMLIonToastElement;
  }
  interface ElementTagNameMap {
      "ion-toast": HTMLIonToastElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-toast": JSXElements.IonToastAttributes;
      }
  }
  namespace JSXElements {
      export interface IonToastAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          animationCtrl?: any,
          message?: string,
          cssClass?: string,
          duration?: number,
          showCloseButton?: boolean,
          closeButtonText?: string,
          dismissOnPageChange?: boolean,
          position?: string,
          enterAnimation?: any,
          exitAnimation?: any,
          toastId?: string
      }
  }
}

import { Toggle as IonToggle } from './components/toggle/toggle';

interface HTMLIonToggleElement extends IonToggle, HTMLElement {
}
declare var HTMLIonToggleElement: {
  prototype: HTMLIonToggleElement;
  new (): HTMLIonToggleElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-toggle": HTMLIonToggleElement;
  }
  interface ElementTagNameMap {
      "ion-toggle": HTMLIonToggleElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-toggle": JSXElements.IonToggleAttributes;
      }
  }
  namespace JSXElements {
      export interface IonToggleAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          checked?: boolean,
          disabled?: boolean,
          value?: string
      }
  }
}

import { Navbar as IonNavbar } from './components/toolbar/navbar';

interface HTMLIonNavbarElement extends IonNavbar, HTMLElement {
}
declare var HTMLIonNavbarElement: {
  prototype: HTMLIonNavbarElement;
  new (): HTMLIonNavbarElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-navbar": HTMLIonNavbarElement;
  }
  interface ElementTagNameMap {
      "ion-navbar": HTMLIonNavbarElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-navbar": JSXElements.IonNavbarAttributes;
      }
  }
  namespace JSXElements {
      export interface IonNavbarAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
          hideBackButton?: boolean,
          backButtonText?: string,
          backButtonIcon?: string,
          hidden?: boolean
      }
  }
}

import { Toolbar as IonToolbar } from './components/toolbar/toolbar';

interface HTMLIonToolbarElement extends IonToolbar, HTMLElement {
}
declare var HTMLIonToolbarElement: {
  prototype: HTMLIonToolbarElement;
  new (): HTMLIonToolbarElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-toolbar": HTMLIonToolbarElement;
  }
  interface ElementTagNameMap {
      "ion-toolbar": HTMLIonToolbarElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-toolbar": JSXElements.IonToolbarAttributes;
      }
  }
  namespace JSXElements {
      export interface IonToolbarAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}

import { IonUtils as IonUtils } from './components/util/util';

interface HTMLIonUtilsElement extends IonUtils, HTMLElement {
}
declare var HTMLIonUtilsElement: {
  prototype: HTMLIonUtilsElement;
  new (): HTMLIonUtilsElement;
};
declare global {
  interface HTMLElementTagNameMap {
      "ion-utils": HTMLIonUtilsElement;
  }
  interface ElementTagNameMap {
      "ion-utils": HTMLIonUtilsElement;
  }
  namespace JSX {
      interface IntrinsicElements {
          "ion-utils": JSXElements.IonUtilsAttributes;
      }
  }
  namespace JSXElements {
      export interface IonUtilsAttributes extends HTMLAttributes {
          mode?: string,
          color?: string,
        
      }
  }
}