diff --git a/packages/core/src/components.d.ts b/packages/core/src/components.d.ts new file mode 100644 index 0000000000..906a58f195 --- /dev/null +++ b/packages/core/src/components.d.ts @@ -0,0 +1,2954 @@ +/** + * 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 { + + 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 { + + animationCtrl?: any, + cssClass?: any, + title?: any, + subTitle?: any, + buttons?: any, + enableBackdropDismiss?: boolean | "true" | "false", + enterAnimation?: any, + exitAnimation?: any, + id?: any + } + } +} + +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 { + + 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 { + + animationCtrl?: any, + cssClass?: any, + title?: any, + subTitle?: any, + message?: any, + buttons?: any, + inputs?: any, + enableBackdropDismiss?: boolean | "true" | "false", + enterAnimation?: any, + exitAnimation?: any, + id?: any + } + } +} + +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 { + + 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 { + + } + } +} + +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 { + + } + } +} + +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 { + + } + } +} + +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 { + + } + } +} + +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 { + + itemButton?: boolean | "true" | "false", + href?: any, + buttonType?: any, + large?: boolean | "true" | "false", + small?: boolean | "true" | "false", + default?: boolean | "true" | "false", + disabled?: boolean | "true" | "false", + outline?: boolean | "true" | "false", + clear?: boolean | "true" | "false", + solid?: boolean | "true" | "false", + round?: boolean | "true" | "false", + block?: boolean | "true" | "false", + full?: boolean | "true" | "false", + strong?: boolean | "true" | "false" + } + } +} + +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 { + + } + } +} + +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 { + + } + } +} + +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 { + + } + } +} + +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 { + + } + } +} + +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 { + + } + } +} + +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 { + + checked?: boolean | "true" | "false", + disabled?: boolean | "true" | "false", + value?: any + } + } +} + +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 { + + href?: any, + clear?: boolean | "true" | "false", + disabled?: boolean | "true" | "false" + } + } +} + +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 { + + } + } +} + +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 { + + ionScrollStart?: any, + ionScroll?: any, + ionScrollEnd?: any, + fullscreen?: boolean | "true" | "false" + } + } +} + +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 { + + pickerCtrl?: any, + disabled?: boolean | "true" | "false", + min?: any, + max?: any, + displayFormat?: any, + pickerFormat?: any, + cancelText?: any, + doneText?: any, + yearValues?: any, + monthValues?: any, + dayValues?: any, + hourValues?: any, + minuteValues?: any, + monthNames?: any, + monthShortNames?: any, + dayNames?: any, + dayShortNames?: any, + pickerOptions?: any, + placeholder?: any, + value?: any + } + } +} + +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 { + + 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 { + + } + } +} + +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 { + + close?: any, + href?: any, + disabled?: boolean | "true" | "false" + } + } +} + +import { Fixed as IonFixed } from './components/fixed/fixed'; + +interface HTMLIonFixedElement extends IonFixed, HTMLElement { +} +declare var HTMLIonFixedElement: { + prototype: HTMLIonFixedElement; + new (): HTMLIonFixedElement; +}; +declare global { + interface HTMLElementTagNameMap { + "ion-fixed": HTMLIonFixedElement; + } + interface ElementTagNameMap { + "ion-fixed": HTMLIonFixedElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-fixed": JSXElements.IonFixedAttributes; + } + } + namespace JSXElements { + export interface IonFixedAttributes extends HTMLAttributes { + + } + } +} + +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 { + + } + } +} + +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 { + + } + } +} + +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 { + + enabled?: boolean | "true" | "false", + attachTo?: any, + autoBlockAll?: boolean | "true" | "false", + block?: any, + disableScroll?: boolean | "true" | "false", + direction?: any, + gestureName?: any, + gesturePriority?: number, + maxAngle?: number, + threshold?: number, + type?: any, + 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 { + + } + } +} + +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 { + + } + } +} + +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 { + + } + } +} + +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 { + + } + } +} + +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 { + + accept?: any, + autocapitalize?: any, + autocomplete?: any, + autocorrect?: any, + autofocus?: boolean | "true" | "false", + checked?: boolean | "true" | "false", + clearInput?: boolean | "true" | "false", + clearOnEdit?: boolean | "true" | "false", + disabled?: boolean | "true" | "false", + inputmode?: any, + max?: any, + maxlength?: number, + min?: any, + minlength?: number, + multiple?: boolean | "true" | "false", + name?: any, + pattern?: any, + placeholder?: any, + readonly?: boolean | "true" | "false", + required?: boolean | "true" | "false", + results?: number, + spellcheck?: boolean | "true" | "false", + step?: any, + size?: number, + type?: any, + value?: any + } + } +} + +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 { + + autocapitalize?: any, + autocomplete?: any, + autofocus?: boolean | "true" | "false", + clearOnEdit?: boolean | "true" | "false", + disabled?: boolean | "true" | "false", + maxlength?: number, + minlength?: number, + name?: any, + placeholder?: any, + readonly?: boolean | "true" | "false", + required?: boolean | "true" | "false", + spellcheck?: boolean | "true" | "false", + cols?: number, + rows?: number, + wrap?: any, + value?: any + } + } +} + +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 { + + } + } +} + +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 { + + href?: any, + disabled?: boolean | "true" | "false" + } + } +} + +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 { + + side?: any + } + } +} + +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 { + + 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 { + + getLabelText?: any, + href?: any + } + } +} + +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 { + + } + } +} + +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 { + + getText?: any, + fixed?: boolean | "true" | "false", + floating?: boolean | "true" | "false", + stacked?: boolean | "true" | "false" + } + } +} + +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 { + + } + } +} + +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 { + + 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 { + + 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 { + + animationCtrl?: any, + cssClass?: any, + content?: any, + dismissOnPageChange?: boolean | "true" | "false", + duration?: number, + enterAnimation?: any, + exitAnimation?: any, + id?: any, + showBackdrop?: boolean | "true" | "false" + } + } +} + +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 { + + 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, + create?: 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 { + + lazyMenuCtrl?: any, + content?: any, + id?: any, + type?: any, + enabled?: boolean | "true" | "false", + side?: any, + swipeEnabled?: boolean | "true" | "false", + persistent?: boolean | "true" | "false", + 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 { + + 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 { + + animationCtrl?: any, + component?: any, + componentProps?: any, + cssClass?: any, + enableBackdropDismiss?: boolean | "true" | "false", + enterAnimation?: any, + exitAnimation?: any, + id?: any, + showBackdrop?: boolean | "true" | "false" + } + } +} + +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 { + + push?: any, + pop?: any, + setRoot?: any, + insert?: any, + insertPages?: any, + popToRoot?: any, + popTo?: any, + remove?: 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 { + + 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 { + + push?: any, + pop?: any, + setRoot?: any, + insert?: any, + insertPages?: any, + popToRoot?: any, + popTo?: any, + remove?: 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 { + + } + } +} + +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 { + + } + } +} + +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 { + + } + } +} + +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 { + + } + } +} + +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 { + + } + } +} + +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 { + + 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 { + + 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 { + + addColumn?: any, + getColumn?: any, + getColumns?: any, + animationCtrl?: any, + cssClass?: any, + content?: any, + dismissOnPageChange?: boolean | "true" | "false", + duration?: number, + enterAnimation?: any, + exitAnimation?: any, + id?: any, + showBackdrop?: boolean | "true" | "false", + enableBackdropDismiss?: boolean | "true" | "false", + 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 { + + 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 { + + animationCtrl?: any, + component?: any, + componentProps?: any, + cssClass?: any, + enableBackdropDismiss?: boolean | "true" | "false", + enterAnimation?: any, + exitAnimation?: any, + ev?: any, + id?: any, + showBackdrop?: boolean | "true" | "false" + } + } +} + +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 { + + allowEmptySelection?: boolean | "true" | "false", + disabled?: boolean | "true" | "false", + value?: any + } + } +} + +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 { + + checked?: boolean | "true" | "false", + disabled?: boolean | "true" | "false", + value?: any + } + } +} + +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 { + + pressed?: boolean | "true" | "false", + pin?: boolean | "true" | "false", + min?: number, + max?: number, + val?: number, + disabled?: boolean | "true" | "false", + labelId?: any, + knob?: any, + 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 { + + ratio?: any, + ratioUpper?: any, + value?: any, + disabled?: boolean | "true" | "false", + min?: number, + max?: number, + steps?: number, + dualKnobs?: boolean | "true" | "false", + pin?: boolean | "true" | "false", + snaps?: boolean | "true" | "false", + 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 { + + enabled?: boolean | "true" | "false" + } + } +} + +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 { + + } + } +} + +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 { + + url?: any, + 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 { + + url?: any, + component?: any, + 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 { + + root?: any, + 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 { + + enabled?: boolean | "true" | "false", + jsScroll?: boolean | "true" | "false", + ionScrollStart?: any, + ionScroll?: any, + ionScrollEnd?: 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 { + + animated?: boolean | "true" | "false", + autocomplete?: any, + autocorrect?: any, + cancelButtonText?: any, + debounce?: number, + placeholder?: any, + showCancelButton?: boolean | "true" | "false", + spellcheck?: boolean | "true" | "false", + type?: any, + value?: any + } + } +} + +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 { + + checked?: boolean | "true" | "false", + disabled?: boolean | "true" | "false", + value?: any + } + } +} + +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 { + + disabled?: boolean | "true" | "false", + value?: any + } + } +} + +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 { + + getText?: any, + disabled?: boolean | "true" | "false", + selected?: boolean | "true" | "false", + value?: any + } + } +} + +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 { + + options?: any, + value?: any + } + } +} + +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 { + + actionSheetCtrl?: any, + alertCtrl?: any, + popoverCtrl?: any, + disabled?: boolean | "true" | "false", + cancelText?: any, + okText?: any, + placeholder?: any, + selectOptions?: any, + interface?: any, + selectedText?: any, + multiple?: boolean | "true" | "false", + 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 { + + width?: any + } + } +} + +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 { + + } + } +} + +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 { + + effect?: any, + autoplay?: number, + control?: any, + direction?: any, + initialSlide?: number, + loop?: boolean | "true" | "false", + pager?: boolean | "true" | "false", + paginationType?: any, + parallax?: boolean | "true" | "false", + slidesPerView?: any, + spaceBetween?: number, + speed?: number, + zoom?: boolean | "true" | "false", + keyboardControl?: boolean | "true" | "false" + } + } +} + +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 { + + duration?: number, + name?: any, + paused?: boolean | "true" | "false" + } + } +} + +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 { + + isVisible?: any, + enabled?: boolean | "true" | "false", + 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 { + + tabs?: any, + onTabSelected?: any, + selectedIndex?: number, + tabsLayout?: any + } + } +} + +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 { + + tab?: any, + layout?: any, + 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 { + + } + } +} + +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 { + + root?: any, + rootParams?: any, + tabTitle?: any, + tabIcon?: any, + tabBadge?: any, + tabBadgeStyle?: any, + enabled?: boolean | "true" | "false", + shown?: boolean | "true" | "false", + tabsHideOnSubPages?: boolean | "true" | "false", + 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 { + + tabsLayout?: any, + tabsPlacement?: any, + tabsHighlight?: boolean | "true" | "false", + 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 { + + } + } +} + +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 { + + } + } +} + +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 { + + 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 { + + animationCtrl?: any, + message?: any, + cssClass?: any, + duration?: number, + showCloseButton?: boolean | "true" | "false", + closeButtonText?: any, + dismissOnPageChange?: boolean | "true" | "false", + position?: any, + enterAnimation?: any, + exitAnimation?: any, + id?: any + } + } +} + +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 { + + checked?: boolean | "true" | "false", + disabled?: boolean | "true" | "false", + value?: any + } + } +} + +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 { + + hideBackButton?: boolean | "true" | "false", + backButtonText?: any, + backButtonIcon?: any, + hidden?: boolean | "true" | "false" + } + } +} + +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 { + + } + } +} + +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 { + + } + } +} +