ionic-framework/packages/core/src/components.d.ts

/**
 * 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 {
  ActionSheetButton,
} from './components/action-sheet/action-sheet';
import {
  AnimationBuilder,
  FrameworkDelegate,
  PickerColumn,
  PickerOptions,
} from './index';
import {
  AlertButton,
  AlertInput,
} from './components/alert/alert';
import {
  ElementRef,
  Side,
} from './utils/helpers';
import {
  GestureCallback,
  GestureDetail,
} from './components/gesture/gesture';
import {
  PickerButton,
  PickerColumn as PickerColumn2,
} from './components/picker/picker';
import {
  Event,
} from '@stencil/core';
import {
  ScrollCallback,
} from './components/scroll/scroll';
import {
  SelectPopoverOption,
} from './components/select-popover/select-popover';
import {
  DomRenderFn,
  HeaderFn,
  ItemHeightFn,
  ItemRenderFn,
  NodeHeightFn,
} from './components/virtual-scroll/virtual-scroll-utils';

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

declare global {
  interface HTMLIonActionSheetControllerElement extends IonActionSheetController, HTMLElement {
  }
  var HTMLIonActionSheetControllerElement: {
    prototype: HTMLIonActionSheetControllerElement;
    new (): HTMLIonActionSheetControllerElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonActionSheetElement extends IonActionSheet, HTMLElement {
  }
  var HTMLIonActionSheetElement: {
    prototype: HTMLIonActionSheetElement;
    new (): HTMLIonActionSheetElement;
  };
  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 {
      buttons?: ActionSheetButton[];
      cssClass?: string;
      enableBackdropDismiss?: boolean;
      enterAnimation?: AnimationBuilder;
      leaveAnimation?: AnimationBuilder;
      subTitle?: string;
      title?: string;
      translucent?: boolean;
      willAnimate?: boolean;
    }
  }
}


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

declare global {
  interface HTMLIonAlertControllerElement extends IonAlertController, HTMLElement {
  }
  var HTMLIonAlertControllerElement: {
    prototype: HTMLIonAlertControllerElement;
    new (): HTMLIonAlertControllerElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonAlertElement extends IonAlert, HTMLElement {
  }
  var HTMLIonAlertElement: {
    prototype: HTMLIonAlertElement;
    new (): HTMLIonAlertElement;
  };
  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 {
      buttons?: AlertButton[];
      cssClass?: string;
      enableBackdropDismiss?: boolean;
      enterAnimation?: AnimationBuilder;
      inputs?: AlertInput[];
      leaveAnimation?: AnimationBuilder;
      message?: string;
      subTitle?: string;
      title?: string;
      translucent?: boolean;
      willAnimate?: boolean;
    }
  }
}


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

declare global {
  interface HTMLIonAnimationControllerElement extends IonAnimationController, HTMLElement {
  }
  var HTMLIonAnimationControllerElement: {
    prototype: HTMLIonAnimationControllerElement;
    new (): HTMLIonAnimationControllerElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonAppElement extends IonApp, HTMLElement {
  }
  var HTMLIonAppElement: {
    prototype: HTMLIonAppElement;
    new (): HTMLIonAppElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonAvatarElement extends IonAvatar, HTMLElement {
  }
  var HTMLIonAvatarElement: {
    prototype: HTMLIonAvatarElement;
    new (): HTMLIonAvatarElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonBackdropElement extends IonBackdrop, HTMLElement {
  }
  var HTMLIonBackdropElement: {
    prototype: HTMLIonBackdropElement;
    new (): HTMLIonBackdropElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonBadgeElement extends IonBadge, HTMLElement {
  }
  var HTMLIonBadgeElement: {
    prototype: HTMLIonBadgeElement;
    new (): HTMLIonBadgeElement;
  };
  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 {
      color?: string;
      mode?: 'ios' | 'md';
    }
  }
}


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

declare global {
  interface HTMLIonButtonElement extends IonButton, HTMLElement {
  }
  var HTMLIonButtonElement: {
    prototype: HTMLIonButtonElement;
    new (): HTMLIonButtonElement;
  };
  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 {
      buttonType?: string;
      color?: string;
      disabled?: boolean;
      expand?: 'full' | 'block';
      fill?: 'clear' | 'outline' | 'solid' | 'default';
      href?: string;
      mode?: 'ios' | 'md';
      round?: boolean;
      size?: 'small' | 'default' | 'large';
      strong?: boolean;
    }
  }
}


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

declare global {
  interface HTMLIonButtonsElement extends IonButtons, HTMLElement {
  }
  var HTMLIonButtonsElement: {
    prototype: HTMLIonButtonsElement;
    new (): HTMLIonButtonsElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonCardContentElement extends IonCardContent, HTMLElement {
  }
  var HTMLIonCardContentElement: {
    prototype: HTMLIonCardContentElement;
    new (): HTMLIonCardContentElement;
  };
  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 {
      color?: string;
      mode?: 'ios' | 'md';
    }
  }
}


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

declare global {
  interface HTMLIonCardHeaderElement extends IonCardHeader, HTMLElement {
  }
  var HTMLIonCardHeaderElement: {
    prototype: HTMLIonCardHeaderElement;
    new (): HTMLIonCardHeaderElement;
  };
  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 {
      color?: string;
      mode?: 'ios' | 'md';
      translucent?: boolean;
    }
  }
}


import {
  CardSubtitle as IonCardSubtitle
} from './components/card-subtitle/card-subtitle';

declare global {
  interface HTMLIonCardSubtitleElement extends IonCardSubtitle, HTMLElement {
  }
  var HTMLIonCardSubtitleElement: {
    prototype: HTMLIonCardSubtitleElement;
    new (): HTMLIonCardSubtitleElement;
  };
  interface HTMLElementTagNameMap {
    "ion-card-subtitle": HTMLIonCardSubtitleElement;
  }
  interface ElementTagNameMap {
    "ion-card-subtitle": HTMLIonCardSubtitleElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      "ion-card-subtitle": JSXElements.IonCardSubtitleAttributes;
    }
  }
  namespace JSXElements {
    export interface IonCardSubtitleAttributes extends HTMLAttributes {
      color?: string;
      mode?: 'ios' | 'md';
    }
  }
}


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

declare global {
  interface HTMLIonCardTitleElement extends IonCardTitle, HTMLElement {
  }
  var HTMLIonCardTitleElement: {
    prototype: HTMLIonCardTitleElement;
    new (): HTMLIonCardTitleElement;
  };
  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 {
      color?: string;
      mode?: 'ios' | 'md';
    }
  }
}


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

declare global {
  interface HTMLIonCardElement extends IonCard, HTMLElement {
  }
  var HTMLIonCardElement: {
    prototype: HTMLIonCardElement;
    new (): HTMLIonCardElement;
  };
  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 {
      color?: string;
      mode?: 'ios' | 'md';
    }
  }
}


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

declare global {
  interface HTMLIonCheckboxElement extends IonCheckbox, HTMLElement {
  }
  var HTMLIonCheckboxElement: {
    prototype: HTMLIonCheckboxElement;
    new (): HTMLIonCheckboxElement;
  };
  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 {
      checked?: boolean;
      color?: string;
      disabled?: boolean;
      mode?: 'ios' | 'md';
      name?: string;
      value?: string;
    }
  }
}


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

declare global {
  interface HTMLIonChipButtonElement extends IonChipButton, HTMLElement {
  }
  var HTMLIonChipButtonElement: {
    prototype: HTMLIonChipButtonElement;
    new (): HTMLIonChipButtonElement;
  };
  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 {
      color?: string;
      disabled?: boolean;
      fill?: string;
      href?: string;
      mode?: 'ios' | 'md';
    }
  }
}


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

declare global {
  interface HTMLIonChipElement extends IonChip, HTMLElement {
  }
  var HTMLIonChipElement: {
    prototype: HTMLIonChipElement;
    new (): HTMLIonChipElement;
  };
  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 {
      color?: string;
      mode?: 'ios' | 'md';
    }
  }
}


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

declare global {
  interface HTMLIonColElement extends IonCol, HTMLElement {
  }
  var HTMLIonColElement: {
    prototype: HTMLIonColElement;
    new (): HTMLIonColElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonContentElement extends IonContent, HTMLElement {
  }
  var HTMLIonContentElement: {
    prototype: HTMLIonContentElement;
    new (): HTMLIonContentElement;
  };
  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 {
      fullscreen?: boolean;
      ionScroll?: Function;
      ionScrollEnd?: Function;
      ionScrollStart?: Function;
    }
  }
}


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

declare global {
  interface HTMLIonDatetimeElement extends IonDatetime, HTMLElement {
  }
  var HTMLIonDatetimeElement: {
    prototype: HTMLIonDatetimeElement;
    new (): HTMLIonDatetimeElement;
  };
  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 {
      cancelText?: string;
      dayNames?: any;
      dayShortNames?: any;
      dayValues?: any;
      disabled?: boolean;
      displayFormat?: string;
      doneText?: string;
      hourValues?: any;
      max?: string;
      min?: string;
      minuteValues?: any;
      monthNames?: any;
      monthShortNames?: any;
      monthValues?: any;
      pickerFormat?: string;
      pickerOptions?: PickerOptions;
      placeholder?: string;
      value?: string;
      yearValues?: any;
    }
  }
}


import {
  Events as IonEvents
} from './components/events/events';

declare global {
  interface HTMLIonEventsElement extends IonEvents, HTMLElement {
  }
  var HTMLIonEventsElement: {
    prototype: HTMLIonEventsElement;
    new (): HTMLIonEventsElement;
  };
  interface HTMLElementTagNameMap {
    "ion-events": HTMLIonEventsElement;
  }
  interface ElementTagNameMap {
    "ion-events": HTMLIonEventsElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      "ion-events": JSXElements.IonEventsAttributes;
    }
  }
  namespace JSXElements {
    export interface IonEventsAttributes extends HTMLAttributes {

    }
  }
}


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

declare global {
  interface HTMLIonFabButtonElement extends IonFabButton, HTMLElement {
  }
  var HTMLIonFabButtonElement: {
    prototype: HTMLIonFabButtonElement;
    new (): HTMLIonFabButtonElement;
  };
  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 {
      activated?: boolean;
      color?: string;
      disabled?: boolean;
      href?: string;
      mode?: 'ios' | 'md';
      show?: boolean;
      toggleActive?: Function;
      translucent?: boolean;
    }
  }
}


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

declare global {
  interface HTMLIonFabListElement extends IonFabList, HTMLElement {
  }
  var HTMLIonFabListElement: {
    prototype: HTMLIonFabListElement;
    new (): HTMLIonFabListElement;
  };
  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 {
      activated?: boolean;
    }
  }
}


import {
  Fab as IonFab
} from './components/fab/fab';

declare global {
  interface HTMLIonFabElement extends IonFab, HTMLElement {
  }
  var HTMLIonFabElement: {
    prototype: HTMLIonFabElement;
    new (): HTMLIonFabElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonFooterElement extends IonFooter, HTMLElement {
  }
  var HTMLIonFooterElement: {
    prototype: HTMLIonFooterElement;
    new (): HTMLIonFooterElement;
  };
  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 {
      translucent?: boolean;
    }
  }
}


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

declare global {
  interface HTMLIonGestureElement extends IonGesture, HTMLElement {
  }
  var HTMLIonGestureElement: {
    prototype: HTMLIonGestureElement;
    new (): HTMLIonGestureElement;
  };
  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 {
      attachTo?: ElementRef;
      autoBlockAll?: boolean;
      block?: string;
      canStart?: GestureCallback;
      direction?: string;
      disabled?: boolean;
      disableScroll?: boolean;
      gestureName?: string;
      gesturePriority?: number;
      maxAngle?: number;
      notCaptured?: GestureCallback;
      onEnd?: GestureCallback;
      onMove?: GestureCallback;
      onPress?: GestureCallback;
      onStart?: GestureCallback;
      onWillStart?: (_: GestureDetail) => Promise<void>;
      passive?: boolean;
      threshold?: number;
      type?: string;
    }
  }
}


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

declare global {
  interface HTMLIonGridElement extends IonGrid, HTMLElement {
  }
  var HTMLIonGridElement: {
    prototype: HTMLIonGridElement;
    new (): HTMLIonGridElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonHeaderElement extends IonHeader, HTMLElement {
  }
  var HTMLIonHeaderElement: {
    prototype: HTMLIonHeaderElement;
    new (): HTMLIonHeaderElement;
  };
  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 {
      translucent?: boolean;
    }
  }
}


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

declare global {
  interface HTMLIonInfiniteScrollContentElement extends IonInfiniteScrollContent, HTMLElement {
  }
  var HTMLIonInfiniteScrollContentElement: {
    prototype: HTMLIonInfiniteScrollContentElement;
    new (): HTMLIonInfiniteScrollContentElement;
  };
  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 {
      loadingSpinner?: string;
      loadingText?: string;
    }
  }
}


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

declare global {
  interface HTMLIonInfiniteScrollElement extends IonInfiniteScroll, HTMLElement {
  }
  var HTMLIonInfiniteScrollElement: {
    prototype: HTMLIonInfiniteScrollElement;
    new (): HTMLIonInfiniteScrollElement;
  };
  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 {
      disabled?: boolean;
      position?: string;
      threshold?: string;
    }
  }
}


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

declare global {
  interface HTMLIonInputElement extends IonInput, HTMLElement {
  }
  var HTMLIonInputElement: {
    prototype: HTMLIonInputElement;
    new (): HTMLIonInputElement;
  };
  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 {
      accept?: string;
      autocapitalize?: string;
      autocomplete?: string;
      autocorrect?: string;
      autofocus?: boolean;
      checked?: boolean;
      clearInput?: boolean;
      clearOnEdit?: boolean;
      debounce?: number;
      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;
      size?: number;
      spellcheck?: boolean;
      step?: string;
      type?: string;
      value?: string;
    }
  }
}


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

declare global {
  interface HTMLIonItemDividerElement extends IonItemDivider, HTMLElement {
  }
  var HTMLIonItemDividerElement: {
    prototype: HTMLIonItemDividerElement;
    new (): HTMLIonItemDividerElement;
  };
  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 {
      color?: string;
      mode?: 'ios' | 'md';
    }
  }
}


import {
  ItemGroup as IonItemGroup
} from './components/item-group/item-group';

declare global {
  interface HTMLIonItemGroupElement extends IonItemGroup, HTMLElement {
  }
  var HTMLIonItemGroupElement: {
    prototype: HTMLIonItemGroupElement;
    new (): HTMLIonItemGroupElement;
  };
  interface HTMLElementTagNameMap {
    "ion-item-group": HTMLIonItemGroupElement;
  }
  interface ElementTagNameMap {
    "ion-item-group": HTMLIonItemGroupElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      "ion-item-group": JSXElements.IonItemGroupAttributes;
    }
  }
  namespace JSXElements {
    export interface IonItemGroupAttributes extends HTMLAttributes {

    }
  }
}


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

declare global {
  interface HTMLIonItemOptionElement extends IonItemOption, HTMLElement {
  }
  var HTMLIonItemOptionElement: {
    prototype: HTMLIonItemOptionElement;
    new (): HTMLIonItemOptionElement;
  };
  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 {
      color?: string;
      disabled?: boolean;
      href?: string;
      mode?: 'ios' | 'md';
    }
  }
}


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

declare global {
  interface HTMLIonItemOptionsElement extends IonItemOptions, HTMLElement {
  }
  var HTMLIonItemOptionsElement: {
    prototype: HTMLIonItemOptionsElement;
    new (): HTMLIonItemOptionsElement;
  };
  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 {
      side?: Side;
    }
  }
}


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

declare global {
  interface HTMLIonItemSlidingElement extends IonItemSliding, HTMLElement {
  }
  var HTMLIonItemSlidingElement: {
    prototype: HTMLIonItemSlidingElement;
    new (): HTMLIonItemSlidingElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonItemElement extends IonItem, HTMLElement {
  }
  var HTMLIonItemElement: {
    prototype: HTMLIonItemElement;
    new (): HTMLIonItemElement;
  };
  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 {
      color?: string;
      href?: string;
      mode?: 'ios' | 'md';
    }
  }
}


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

declare global {
  interface HTMLIonKeyboardControllerElement extends IonKeyboardController, HTMLElement {
  }
  var HTMLIonKeyboardControllerElement: {
    prototype: HTMLIonKeyboardControllerElement;
    new (): HTMLIonKeyboardControllerElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonLabelElement extends IonLabel, HTMLElement {
  }
  var HTMLIonLabelElement: {
    prototype: HTMLIonLabelElement;
    new (): HTMLIonLabelElement;
  };
  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 {
      color?: string;
      fixed?: boolean;
      floating?: boolean;
      mode?: 'ios' | 'md';
      stacked?: boolean;
    }
  }
}


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

declare global {
  interface HTMLIonListHeaderElement extends IonListHeader, HTMLElement {
  }
  var HTMLIonListHeaderElement: {
    prototype: HTMLIonListHeaderElement;
    new (): HTMLIonListHeaderElement;
  };
  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 {
      color?: string;
      mode?: 'ios' | 'md';
    }
  }
}


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

declare global {
  interface HTMLIonListElement extends IonList, HTMLElement {
  }
  var HTMLIonListElement: {
    prototype: HTMLIonListElement;
    new (): HTMLIonListElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonLoadingControllerElement extends IonLoadingController, HTMLElement {
  }
  var HTMLIonLoadingControllerElement: {
    prototype: HTMLIonLoadingControllerElement;
    new (): HTMLIonLoadingControllerElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonLoadingElement extends IonLoading, HTMLElement {
  }
  var HTMLIonLoadingElement: {
    prototype: HTMLIonLoadingElement;
    new (): HTMLIonLoadingElement;
  };
  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 {
      content?: string;
      cssClass?: string;
      dismissOnPageChange?: boolean;
      duration?: number;
      enterAnimation?: AnimationBuilder;
      leaveAnimation?: AnimationBuilder;
      showBackdrop?: boolean;
      spinner?: string;
      translucent?: boolean;
      willAnimate?: boolean;
    }
  }
}


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

declare global {
  interface HTMLIonMenuControllerElement extends IonMenuController, HTMLElement {
  }
  var HTMLIonMenuControllerElement: {
    prototype: HTMLIonMenuControllerElement;
    new (): HTMLIonMenuControllerElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonMenuElement extends IonMenu, HTMLElement {
  }
  var HTMLIonMenuElement: {
    prototype: HTMLIonMenuElement;
    new (): HTMLIonMenuElement;
  };
  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 {
      content?: string;
      disabled?: boolean;
      maxEdgeStart?: number;
      menuId?: string;
      persistent?: boolean;
      side?: Side;
      swipeEnabled?: boolean;
      type?: string;
    }
  }
}


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

declare global {
  interface HTMLIonModalControllerElement extends IonModalController, HTMLElement {
  }
  var HTMLIonModalControllerElement: {
    prototype: HTMLIonModalControllerElement;
    new (): HTMLIonModalControllerElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonModalElement extends IonModal, HTMLElement {
  }
  var HTMLIonModalElement: {
    prototype: HTMLIonModalElement;
    new (): HTMLIonModalElement;
  };
  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 {
      color?: string;
      component?: any;
      cssClass?: string;
      data?: any;
      delegate?: FrameworkDelegate;
      enableBackdropDismiss?: boolean;
      enterAnimation?: AnimationBuilder;
      leaveAnimation?: AnimationBuilder;
      modalId?: number;
      mode?: 'ios' | 'md';
      showBackdrop?: boolean;
      willAnimate?: boolean;
    }
  }
}


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

declare global {
  interface HTMLIonNavElement extends IonNav, HTMLElement {
  }
  var HTMLIonNavElement: {
    prototype: HTMLIonNavElement;
    new (): HTMLIonNavElement;
  };
  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 {
      delegate?: FrameworkDelegate;
      lazy?: boolean;
      mode?: string;
      root?: any;
      useUrls?: boolean;
    }
  }
}


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

declare global {
  interface HTMLIonNoteElement extends IonNote, HTMLElement {
  }
  var HTMLIonNoteElement: {
    prototype: HTMLIonNoteElement;
    new (): HTMLIonNoteElement;
  };
  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 {
      color?: string;
      mode?: 'ios' | 'md';
    }
  }
}


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

declare global {
  interface HTMLIonPageElement extends IonPage, HTMLElement {
  }
  var HTMLIonPageElement: {
    prototype: HTMLIonPageElement;
    new (): HTMLIonPageElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonPickerColumnElement extends IonPickerColumn, HTMLElement {
  }
  var HTMLIonPickerColumnElement: {
    prototype: HTMLIonPickerColumnElement;
    new (): HTMLIonPickerColumnElement;
  };
  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 {
      col?: PickerColumn;
    }
  }
}


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

declare global {
  interface HTMLIonPickerControllerElement extends IonPickerController, HTMLElement {
  }
  var HTMLIonPickerControllerElement: {
    prototype: HTMLIonPickerControllerElement;
    new (): HTMLIonPickerControllerElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonPickerElement extends IonPicker, HTMLElement {
  }
  var HTMLIonPickerElement: {
    prototype: HTMLIonPickerElement;
    new (): HTMLIonPickerElement;
  };
  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 {
      buttons?: PickerButton[];
      columns?: PickerColumn[];
      content?: string;
      cssClass?: string;
      dismissOnPageChange?: boolean;
      duration?: number;
      enableBackdropDismiss?: boolean;
      enterAnimation?: AnimationBuilder;
      leaveAnimation?: AnimationBuilder;
      pickerId?: number;
      showBackdrop?: boolean;
      willAnimate?: boolean;
    }
  }
}


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

declare global {
  interface HTMLIonPopoverControllerElement extends IonPopoverController, HTMLElement {
  }
  var HTMLIonPopoverControllerElement: {
    prototype: HTMLIonPopoverControllerElement;
    new (): HTMLIonPopoverControllerElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonPopoverElement extends IonPopover, HTMLElement {
  }
  var HTMLIonPopoverElement: {
    prototype: HTMLIonPopoverElement;
    new (): HTMLIonPopoverElement;
  };
  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 {
      color?: string;
      component?: string;
      cssClass?: string;
      data?: any;
      delegate?: FrameworkDelegate;
      enableBackdropDismiss?: boolean;
      enterAnimation?: AnimationBuilder;
      ev?: Event;
      leaveAnimation?: AnimationBuilder;
      mode?: 'ios' | 'md';
      popoverId?: number;
      showBackdrop?: boolean;
      translucent?: boolean;
      willAnimate?: boolean;
    }
  }
}


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

declare global {
  interface HTMLIonRadioGroupElement extends IonRadioGroup, HTMLElement {
  }
  var HTMLIonRadioGroupElement: {
    prototype: HTMLIonRadioGroupElement;
    new (): HTMLIonRadioGroupElement;
  };
  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 {
      allowEmptySelection?: boolean;
      disabled?: boolean;
      name?: string;
      value?: string;
    }
  }
}


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

declare global {
  interface HTMLIonRadioElement extends IonRadio, HTMLElement {
  }
  var HTMLIonRadioElement: {
    prototype: HTMLIonRadioElement;
    new (): HTMLIonRadioElement;
  };
  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 {
      checked?: boolean;
      color?: string;
      disabled?: boolean;
      mode?: 'ios' | 'md';
      name?: string;
      value?: string;
    }
  }
}


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

declare global {
  interface HTMLIonRangeKnobElement extends IonRangeKnob, HTMLElement {
  }
  var HTMLIonRangeKnobElement: {
    prototype: HTMLIonRangeKnobElement;
    new (): HTMLIonRangeKnobElement;
  };
  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 {
      disabled?: boolean;
      knob?: string;
      labelId?: string;
      max?: number;
      min?: number;
      pin?: boolean;
      pressed?: boolean;
      ratio?: number;
      val?: number;
    }
  }
}


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

declare global {
  interface HTMLIonRangeElement extends IonRange, HTMLElement {
  }
  var HTMLIonRangeElement: {
    prototype: HTMLIonRangeElement;
    new (): HTMLIonRangeElement;
  };
  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 {
      color?: string;
      debounce?: number;
      disabled?: boolean;
      dualKnobs?: boolean;
      max?: number;
      min?: number;
      mode?: 'ios' | 'md';
      pin?: boolean;
      snaps?: boolean;
      step?: number;
      value?: any;
    }
  }
}


import {
  RefresherContent as IonRefresherContent
} from './components/refresher-content/refresher-content';

declare global {
  interface HTMLIonRefresherContentElement extends IonRefresherContent, HTMLElement {
  }
  var HTMLIonRefresherContentElement: {
    prototype: HTMLIonRefresherContentElement;
    new (): HTMLIonRefresherContentElement;
  };
  interface HTMLElementTagNameMap {
    "ion-refresher-content": HTMLIonRefresherContentElement;
  }
  interface ElementTagNameMap {
    "ion-refresher-content": HTMLIonRefresherContentElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      "ion-refresher-content": JSXElements.IonRefresherContentAttributes;
    }
  }
  namespace JSXElements {
    export interface IonRefresherContentAttributes extends HTMLAttributes {
      pullingIcon?: string;
      pullingText?: string;
      refreshingSpinner?: string;
      refreshingText?: string;
    }
  }
}


import {
  Refresher as IonRefresher
} from './components/refresher/refresher';

declare global {
  interface HTMLIonRefresherElement extends IonRefresher, HTMLElement {
  }
  var HTMLIonRefresherElement: {
    prototype: HTMLIonRefresherElement;
    new (): HTMLIonRefresherElement;
  };
  interface HTMLElementTagNameMap {
    "ion-refresher": HTMLIonRefresherElement;
  }
  interface ElementTagNameMap {
    "ion-refresher": HTMLIonRefresherElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      "ion-refresher": JSXElements.IonRefresherAttributes;
    }
  }
  namespace JSXElements {
    export interface IonRefresherAttributes extends HTMLAttributes {
      closeDuration?: string;
      disabled?: boolean;
      pullMax?: any;
      pullMin?: number;
      snapbackDuration?: string;
    }
  }
}


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

declare global {
  interface HTMLIonReorderGroupElement extends IonReorderGroup, HTMLElement {
  }
  var HTMLIonReorderGroupElement: {
    prototype: HTMLIonReorderGroupElement;
    new (): HTMLIonReorderGroupElement;
  };
  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 {
      disabled?: boolean;
    }
  }
}


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

declare global {
  interface HTMLIonReorderElement extends IonReorder, HTMLElement {
  }
  var HTMLIonReorderElement: {
    prototype: HTMLIonReorderElement;
    new (): HTMLIonReorderElement;
  };
  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 {

    }
  }
}


import {
  RippleEffect as IonRippleEffect
} from './components/ripple-effect/ripple-effect';

declare global {
  interface HTMLIonRippleEffectElement extends IonRippleEffect, HTMLElement {
  }
  var HTMLIonRippleEffectElement: {
    prototype: HTMLIonRippleEffectElement;
    new (): HTMLIonRippleEffectElement;
  };
  interface HTMLElementTagNameMap {
    "ion-ripple-effect": HTMLIonRippleEffectElement;
  }
  interface ElementTagNameMap {
    "ion-ripple-effect": HTMLIonRippleEffectElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      "ion-ripple-effect": JSXElements.IonRippleEffectAttributes;
    }
  }
  namespace JSXElements {
    export interface IonRippleEffectAttributes extends HTMLAttributes {
      useTapClick?: boolean;
    }
  }
}


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

declare global {
  interface HTMLIonRouteLinkElement extends IonRouteLink, HTMLElement {
  }
  var HTMLIonRouteLinkElement: {
    prototype: HTMLIonRouteLinkElement;
    new (): HTMLIonRouteLinkElement;
  };
  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 {
      router?: any;
      url?: string;
    }
  }
}


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

declare global {
  interface HTMLIonRouteElement extends IonRoute, HTMLElement {
  }
  var HTMLIonRouteElement: {
    prototype: HTMLIonRouteElement;
    new (): HTMLIonRouteElement;
  };
  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 {
      component?: string;
      path?: string;
      props?: any;
    }
  }
}


import {
  RouterController as IonRouterController
} from './components/router-controller/router-controller';

declare global {
  interface HTMLIonRouterControllerElement extends IonRouterController, HTMLElement {
  }
  var HTMLIonRouterControllerElement: {
    prototype: HTMLIonRouterControllerElement;
    new (): HTMLIonRouterControllerElement;
  };
  interface HTMLElementTagNameMap {
    "ion-router-controller": HTMLIonRouterControllerElement;
  }
  interface ElementTagNameMap {
    "ion-router-controller": HTMLIonRouterControllerElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      "ion-router-controller": JSXElements.IonRouterControllerAttributes;
    }
  }
  namespace JSXElements {
    export interface IonRouterControllerAttributes extends HTMLAttributes {

    }
  }
}


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

declare global {
  interface HTMLIonRowElement extends IonRow, HTMLElement {
  }
  var HTMLIonRowElement: {
    prototype: HTMLIonRowElement;
    new (): HTMLIonRowElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonScrollElement extends IonScroll, HTMLElement {
  }
  var HTMLIonScrollElement: {
    prototype: HTMLIonScrollElement;
    new (): HTMLIonScrollElement;
  };
  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 {
      disabled?: boolean;
      onionScroll?: ScrollCallback;
      onionScrollEnd?: ScrollCallback;
      onionScrollStart?: ScrollCallback;
    }
  }
}


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

declare global {
  interface HTMLIonSearchbarElement extends IonSearchbar, HTMLElement {
  }
  var HTMLIonSearchbarElement: {
    prototype: HTMLIonSearchbarElement;
    new (): HTMLIonSearchbarElement;
  };
  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 {
      animated?: boolean;
      autocomplete?: string;
      autocorrect?: string;
      cancelButtonText?: string;
      color?: string;
      debounce?: number;
      mode?: 'ios' | 'md';
      placeholder?: string;
      showCancelButton?: boolean;
      spellcheck?: boolean;
      type?: string;
      value?: string;
    }
  }
}


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

declare global {
  interface HTMLIonSegmentButtonElement extends IonSegmentButton, HTMLElement {
  }
  var HTMLIonSegmentButtonElement: {
    prototype: HTMLIonSegmentButtonElement;
    new (): HTMLIonSegmentButtonElement;
  };
  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 {
      activated?: boolean;
      checked?: boolean;
      color?: string;
      disabled?: boolean;
      href?: string;
      mode?: 'ios' | 'md';
      value?: string;
    }
  }
}


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

declare global {
  interface HTMLIonSegmentElement extends IonSegment, HTMLElement {
  }
  var HTMLIonSegmentElement: {
    prototype: HTMLIonSegmentElement;
    new (): HTMLIonSegmentElement;
  };
  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 {
      color?: string;
      disabled?: boolean;
      mode?: 'ios' | 'md';
      value?: string;
    }
  }
}


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

declare global {
  interface HTMLIonSelectOptionElement extends IonSelectOption, HTMLElement {
  }
  var HTMLIonSelectOptionElement: {
    prototype: HTMLIonSelectOptionElement;
    new (): HTMLIonSelectOptionElement;
  };
  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 {
      disabled?: boolean;
      selected?: boolean;
      value?: string;
    }
  }
}


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

declare global {
  interface HTMLIonSelectPopoverElement extends IonSelectPopover, HTMLElement {
  }
  var HTMLIonSelectPopoverElement: {
    prototype: HTMLIonSelectPopoverElement;
    new (): HTMLIonSelectPopoverElement;
  };
  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 {
      message?: string;
      options?: SelectPopoverOption[];
      subTitle?: string;
      title?: string;
    }
  }
}


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

declare global {
  interface HTMLIonSelectElement extends IonSelect, HTMLElement {
  }
  var HTMLIonSelectElement: {
    prototype: HTMLIonSelectElement;
    new (): HTMLIonSelectElement;
  };
  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 {
      cancelText?: string;
      disabled?: boolean;
      interface?: string;
      interfaceOptions?: any;
      multiple?: boolean;
      name?: string;
      okText?: string;
      placeholder?: string;
      selectedText?: string;
      value?: string | string[];
    }
  }
}


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

declare global {
  interface HTMLIonSkeletonTextElement extends IonSkeletonText, HTMLElement {
  }
  var HTMLIonSkeletonTextElement: {
    prototype: HTMLIonSkeletonTextElement;
    new (): HTMLIonSkeletonTextElement;
  };
  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 {
      width?: string;
    }
  }
}


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

declare global {
  interface HTMLIonSlideElement extends IonSlide, HTMLElement {
  }
  var HTMLIonSlideElement: {
    prototype: HTMLIonSlideElement;
    new (): HTMLIonSlideElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonSlidesElement extends IonSlides, HTMLElement {
  }
  var HTMLIonSlidesElement: {
    prototype: HTMLIonSlidesElement;
    new (): HTMLIonSlidesElement;
  };
  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 {
      options?: any;
      pager?: boolean;
    }
  }
}


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

declare global {
  interface HTMLIonSpinnerElement extends IonSpinner, HTMLElement {
  }
  var HTMLIonSpinnerElement: {
    prototype: HTMLIonSpinnerElement;
    new (): HTMLIonSpinnerElement;
  };
  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 {
      color?: string;
      duration?: number;
      mode?: 'ios' | 'md';
      name?: string;
      paused?: boolean;
    }
  }
}


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

declare global {
  interface HTMLIonSplitPaneElement extends IonSplitPane, HTMLElement {
  }
  var HTMLIonSplitPaneElement: {
    prototype: HTMLIonSplitPaneElement;
    new (): HTMLIonSplitPaneElement;
  };
  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 {
      disabled?: boolean;
      when?: string | boolean;
    }
  }
}


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

declare global {
  interface HTMLIonTabButtonElement extends IonTabButton, HTMLElement {
  }
  var HTMLIonTabButtonElement: {
    prototype: HTMLIonTabButtonElement;
    new (): HTMLIonTabButtonElement;
  };
  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?: 'ios' | 'md';
      selected?: boolean;
      tab?: HTMLIonTabElement;
    }
  }
}


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

declare global {
  interface HTMLIonTabElement extends IonTab, HTMLElement {
  }
  var HTMLIonTabElement: {
    prototype: HTMLIonTabElement;
    new (): HTMLIonTabElement;
  };
  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 {
      badge?: string;
      badgeStyle?: string;
      btnId?: string;
      disabled?: boolean;
      icon?: string;
      path?: string;
      selected?: boolean;
      show?: boolean;
      tabsHideOnSubPages?: boolean;
      title?: string;
    }
  }
}


import {
  Tabbar as IonTabbar
} from './components/tabbar/tabbar';

declare global {
  interface HTMLIonTabbarElement extends IonTabbar, HTMLElement {
  }
  var HTMLIonTabbarElement: {
    prototype: HTMLIonTabbarElement;
    new (): HTMLIonTabbarElement;
  };
  interface HTMLElementTagNameMap {
    "ion-tabbar": HTMLIonTabbarElement;
  }
  interface ElementTagNameMap {
    "ion-tabbar": HTMLIonTabbarElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      "ion-tabbar": JSXElements.IonTabbarAttributes;
    }
  }
  namespace JSXElements {
    export interface IonTabbarAttributes extends HTMLAttributes {
      highlight?: boolean;
      layout?: string;
      placement?: string;
      scrollable?: Boolean;
      selectedTab?: HTMLIonTabElement;
      tabs?: HTMLIonTabElement[];
      translucent?: boolean;
    }
  }
}


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

declare global {
  interface HTMLIonTabsElement extends IonTabs, HTMLElement {
  }
  var HTMLIonTabsElement: {
    prototype: HTMLIonTabsElement;
    new (): HTMLIonTabsElement;
  };
  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 {
      name?: string;
      scrollable?: boolean;
      tabbarHidden?: boolean;
      tabbarHighlight?: boolean;
      tabbarLayout?: string;
      tabbarPlacement?: string;
      translucent?: boolean;
    }
  }
}


import {
  TapClick as IonTapClick
} from './components/tap-click/tap-click';

declare global {
  interface HTMLIonTapClickElement extends IonTapClick, HTMLElement {
  }
  var HTMLIonTapClickElement: {
    prototype: HTMLIonTapClickElement;
    new (): HTMLIonTapClickElement;
  };
  interface HTMLElementTagNameMap {
    "ion-tap-click": HTMLIonTapClickElement;
  }
  interface ElementTagNameMap {
    "ion-tap-click": HTMLIonTapClickElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      "ion-tap-click": JSXElements.IonTapClickAttributes;
    }
  }
  namespace JSXElements {
    export interface IonTapClickAttributes extends HTMLAttributes {

    }
  }
}


import {
  Text as IonText
} from './components/text/text';

declare global {
  interface HTMLIonTextElement extends IonText, HTMLElement {
  }
  var HTMLIonTextElement: {
    prototype: HTMLIonTextElement;
    new (): HTMLIonTextElement;
  };
  interface HTMLElementTagNameMap {
    "ion-text": HTMLIonTextElement;
  }
  interface ElementTagNameMap {
    "ion-text": HTMLIonTextElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      "ion-text": JSXElements.IonTextAttributes;
    }
  }
  namespace JSXElements {
    export interface IonTextAttributes extends HTMLAttributes {
      color?: string;
      mode?: 'ios' | 'md';
    }
  }
}


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

declare global {
  interface HTMLIonTextareaElement extends IonTextarea, HTMLElement {
  }
  var HTMLIonTextareaElement: {
    prototype: HTMLIonTextareaElement;
    new (): HTMLIonTextareaElement;
  };
  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 {
      autocapitalize?: string;
      autocomplete?: string;
      autofocus?: boolean;
      clearOnEdit?: boolean;
      cols?: number;
      debounce?: number;
      disabled?: boolean;
      maxlength?: number;
      minlength?: number;
      name?: string;
      placeholder?: string;
      readonly?: boolean;
      required?: boolean;
      rows?: number;
      spellcheck?: boolean;
      value?: string;
      wrap?: string;
    }
  }
}


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

declare global {
  interface HTMLIonThumbnailElement extends IonThumbnail, HTMLElement {
  }
  var HTMLIonThumbnailElement: {
    prototype: HTMLIonThumbnailElement;
    new (): HTMLIonThumbnailElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonTitleElement extends IonTitle, HTMLElement {
  }
  var HTMLIonTitleElement: {
    prototype: HTMLIonTitleElement;
    new (): HTMLIonTitleElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonToastControllerElement extends IonToastController, HTMLElement {
  }
  var HTMLIonToastControllerElement: {
    prototype: HTMLIonToastControllerElement;
    new (): HTMLIonToastControllerElement;
  };
  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 {

    }
  }
}


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

declare global {
  interface HTMLIonToastElement extends IonToast, HTMLElement {
  }
  var HTMLIonToastElement: {
    prototype: HTMLIonToastElement;
    new (): HTMLIonToastElement;
  };
  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 {
      closeButtonText?: string;
      cssClass?: string;
      dismissOnPageChange?: boolean;
      duration?: number;
      enterAnimation?: AnimationBuilder;
      leaveAnimation?: AnimationBuilder;
      message?: string;
      position?: string;
      showCloseButton?: boolean;
      toastId?: number;
      translucent?: boolean;
      willAnimate?: boolean;
    }
  }
}


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

declare global {
  interface HTMLIonToggleElement extends IonToggle, HTMLElement {
  }
  var HTMLIonToggleElement: {
    prototype: HTMLIonToggleElement;
    new (): HTMLIonToggleElement;
  };
  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 {
      checked?: boolean;
      color?: string;
      disabled?: boolean;
      mode?: 'ios' | 'md';
      name?: string;
      value?: string;
    }
  }
}


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

declare global {
  interface HTMLIonToolbarElement extends IonToolbar, HTMLElement {
  }
  var HTMLIonToolbarElement: {
    prototype: HTMLIonToolbarElement;
    new (): HTMLIonToolbarElement;
  };
  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 {
      color?: string;
      mode?: 'ios' | 'md';
      translucent?: boolean;
    }
  }
}


import {
  VirtualScroll as IonVirtualScroll
} from './components/virtual-scroll/virtual-scroll';

declare global {
  interface HTMLIonVirtualScrollElement extends IonVirtualScroll, HTMLElement {
  }
  var HTMLIonVirtualScrollElement: {
    prototype: HTMLIonVirtualScrollElement;
    new (): HTMLIonVirtualScrollElement;
  };
  interface HTMLElementTagNameMap {
    "ion-virtual-scroll": HTMLIonVirtualScrollElement;
  }
  interface ElementTagNameMap {
    "ion-virtual-scroll": HTMLIonVirtualScrollElement;
  }
  namespace JSX {
    interface IntrinsicElements {
      "ion-virtual-scroll": JSXElements.IonVirtualScrollAttributes;
    }
  }
  namespace JSXElements {
    export interface IonVirtualScrollAttributes extends HTMLAttributes {
      approxFooterHeight?: number;
      approxHeaderHeight?: number;
      approxItemHeight?: number;
      domRender?: DomRenderFn;
      footerFn?: HeaderFn;
      headerFn?: HeaderFn;
      itemHeight?: ItemHeightFn;
      itemRender?: ItemRenderFn;
      items?: any[];
      nodeHeight?: NodeHeightFn;
    }
  }
}

declare global { namespace JSX { interface StencilJSX {} } }