mirror of
https://github.com/ionic-team/ionic-framework.git
synced 2025-08-23 05:58:26 +08:00
3199 lines
82 KiB
TypeScript
3199 lines
82 KiB
TypeScript
/**
|
|
* This is an autogenerated file created by the Stencil build process.
|
|
* It contains typing information for all components that exist in this project
|
|
* and imports for stencil collections that might be configured in your stencil.config.js file
|
|
*/
|
|
|
|
import 'ionicons';
|
|
|
|
import { ActionSheetController as IonActionSheetController } from './components/action-sheet-controller/action-sheet-controller';
|
|
|
|
interface HTMLIonActionSheetControllerElement extends IonActionSheetController, HTMLElement {
|
|
}
|
|
declare var HTMLIonActionSheetControllerElement: {
|
|
prototype: HTMLIonActionSheetControllerElement;
|
|
new (): HTMLIonActionSheetControllerElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-action-sheet-controller": HTMLIonActionSheetControllerElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-action-sheet-controller": HTMLIonActionSheetControllerElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-action-sheet-controller": JSXElements.IonActionSheetControllerAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonActionSheetControllerAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
create?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { ActionSheet as IonActionSheet } from './components/action-sheet/action-sheet';
|
|
|
|
interface HTMLIonActionSheetElement extends IonActionSheet, HTMLElement {
|
|
}
|
|
declare var HTMLIonActionSheetElement: {
|
|
prototype: HTMLIonActionSheetElement;
|
|
new (): HTMLIonActionSheetElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-action-sheet": HTMLIonActionSheetElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-action-sheet": HTMLIonActionSheetElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-action-sheet": JSXElements.IonActionSheetAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonActionSheetAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
animationCtrl?: any,
|
|
cssClass?: string,
|
|
title?: string,
|
|
subTitle?: string,
|
|
buttons?: any,
|
|
enableBackdropDismiss?: boolean,
|
|
enterAnimation?: any,
|
|
exitAnimation?: any,
|
|
actionSheetId?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { AlertController as IonAlertController } from './components/alert-controller/alert-controller';
|
|
|
|
interface HTMLIonAlertControllerElement extends IonAlertController, HTMLElement {
|
|
}
|
|
declare var HTMLIonAlertControllerElement: {
|
|
prototype: HTMLIonAlertControllerElement;
|
|
new (): HTMLIonAlertControllerElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-alert-controller": HTMLIonAlertControllerElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-alert-controller": HTMLIonAlertControllerElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-alert-controller": JSXElements.IonAlertControllerAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonAlertControllerAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
create?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Alert as IonAlert } from './components/alert/alert';
|
|
|
|
interface HTMLIonAlertElement extends IonAlert, HTMLElement {
|
|
}
|
|
declare var HTMLIonAlertElement: {
|
|
prototype: HTMLIonAlertElement;
|
|
new (): HTMLIonAlertElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-alert": HTMLIonAlertElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-alert": HTMLIonAlertElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-alert": JSXElements.IonAlertAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonAlertAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
animationCtrl?: any,
|
|
cssClass?: string,
|
|
title?: string,
|
|
subTitle?: string,
|
|
message?: string,
|
|
buttons?: any,
|
|
inputs?: any,
|
|
enableBackdropDismiss?: boolean,
|
|
enterAnimation?: any,
|
|
exitAnimation?: any,
|
|
alertId?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { AnimationControllerImpl as IonAnimationController } from './components/animation-controller/animation-controller';
|
|
|
|
interface HTMLIonAnimationControllerElement extends IonAnimationController, HTMLElement {
|
|
}
|
|
declare var HTMLIonAnimationControllerElement: {
|
|
prototype: HTMLIonAnimationControllerElement;
|
|
new (): HTMLIonAnimationControllerElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-animation-controller": HTMLIonAnimationControllerElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-animation-controller": HTMLIonAnimationControllerElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-animation-controller": JSXElements.IonAnimationControllerAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonAnimationControllerAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
create?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { IonApp as IonApp } from './components/app/app';
|
|
|
|
interface HTMLIonAppElement extends IonApp, HTMLElement {
|
|
}
|
|
declare var HTMLIonAppElement: {
|
|
prototype: HTMLIonAppElement;
|
|
new (): HTMLIonAppElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-app": HTMLIonAppElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-app": HTMLIonAppElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-app": JSXElements.IonAppAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonAppAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Avatar as IonAvatar } from './components/avatar/avatar';
|
|
|
|
interface HTMLIonAvatarElement extends IonAvatar, HTMLElement {
|
|
}
|
|
declare var HTMLIonAvatarElement: {
|
|
prototype: HTMLIonAvatarElement;
|
|
new (): HTMLIonAvatarElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-avatar": HTMLIonAvatarElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-avatar": HTMLIonAvatarElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-avatar": JSXElements.IonAvatarAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonAvatarAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Backdrop as IonBackdrop } from './components/backdrop/backdrop';
|
|
|
|
interface HTMLIonBackdropElement extends IonBackdrop, HTMLElement {
|
|
}
|
|
declare var HTMLIonBackdropElement: {
|
|
prototype: HTMLIonBackdropElement;
|
|
new (): HTMLIonBackdropElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-backdrop": HTMLIonBackdropElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-backdrop": HTMLIonBackdropElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-backdrop": JSXElements.IonBackdropAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonBackdropAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Badge as IonBadge } from './components/badge/badge';
|
|
|
|
interface HTMLIonBadgeElement extends IonBadge, HTMLElement {
|
|
}
|
|
declare var HTMLIonBadgeElement: {
|
|
prototype: HTMLIonBadgeElement;
|
|
new (): HTMLIonBadgeElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-badge": HTMLIonBadgeElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-badge": HTMLIonBadgeElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-badge": JSXElements.IonBadgeAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonBadgeAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Button as IonButton } from './components/button/button';
|
|
|
|
interface HTMLIonButtonElement extends IonButton, HTMLElement {
|
|
}
|
|
declare var HTMLIonButtonElement: {
|
|
prototype: HTMLIonButtonElement;
|
|
new (): HTMLIonButtonElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-button": HTMLIonButtonElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-button": HTMLIonButtonElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-button": JSXElements.IonButtonAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonButtonAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
itemButton?: boolean,
|
|
href?: string,
|
|
buttonType?: string,
|
|
large?: boolean,
|
|
small?: boolean,
|
|
default?: boolean,
|
|
disabled?: boolean,
|
|
outline?: boolean,
|
|
clear?: boolean,
|
|
solid?: boolean,
|
|
round?: boolean,
|
|
block?: boolean,
|
|
full?: boolean,
|
|
strong?: boolean
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Buttons as IonButtons } from './components/buttons/buttons';
|
|
|
|
interface HTMLIonButtonsElement extends IonButtons, HTMLElement {
|
|
}
|
|
declare var HTMLIonButtonsElement: {
|
|
prototype: HTMLIonButtonsElement;
|
|
new (): HTMLIonButtonsElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-buttons": HTMLIonButtonsElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-buttons": HTMLIonButtonsElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-buttons": JSXElements.IonButtonsAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonButtonsAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { CardContent as IonCardContent } from './components/card-content/card-content';
|
|
|
|
interface HTMLIonCardContentElement extends IonCardContent, HTMLElement {
|
|
}
|
|
declare var HTMLIonCardContentElement: {
|
|
prototype: HTMLIonCardContentElement;
|
|
new (): HTMLIonCardContentElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-card-content": HTMLIonCardContentElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-card-content": HTMLIonCardContentElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-card-content": JSXElements.IonCardContentAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonCardContentAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { CardHeader as IonCardHeader } from './components/card-header/card-header';
|
|
|
|
interface HTMLIonCardHeaderElement extends IonCardHeader, HTMLElement {
|
|
}
|
|
declare var HTMLIonCardHeaderElement: {
|
|
prototype: HTMLIonCardHeaderElement;
|
|
new (): HTMLIonCardHeaderElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-card-header": HTMLIonCardHeaderElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-card-header": HTMLIonCardHeaderElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-card-header": JSXElements.IonCardHeaderAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonCardHeaderAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { CardTitle as IonCardTitle } from './components/card-title/card-title';
|
|
|
|
interface HTMLIonCardTitleElement extends IonCardTitle, HTMLElement {
|
|
}
|
|
declare var HTMLIonCardTitleElement: {
|
|
prototype: HTMLIonCardTitleElement;
|
|
new (): HTMLIonCardTitleElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-card-title": HTMLIonCardTitleElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-card-title": HTMLIonCardTitleElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-card-title": JSXElements.IonCardTitleAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonCardTitleAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Card as IonCard } from './components/card/card';
|
|
|
|
interface HTMLIonCardElement extends IonCard, HTMLElement {
|
|
}
|
|
declare var HTMLIonCardElement: {
|
|
prototype: HTMLIonCardElement;
|
|
new (): HTMLIonCardElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-card": HTMLIonCardElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-card": HTMLIonCardElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-card": JSXElements.IonCardAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonCardAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Checkbox as IonCheckbox } from './components/checkbox/checkbox';
|
|
|
|
interface HTMLIonCheckboxElement extends IonCheckbox, HTMLElement {
|
|
}
|
|
declare var HTMLIonCheckboxElement: {
|
|
prototype: HTMLIonCheckboxElement;
|
|
new (): HTMLIonCheckboxElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-checkbox": HTMLIonCheckboxElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-checkbox": HTMLIonCheckboxElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-checkbox": JSXElements.IonCheckboxAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonCheckboxAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
checked?: boolean,
|
|
disabled?: boolean,
|
|
value?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { ChipButton as IonChipButton } from './components/chip-button/chip-button';
|
|
|
|
interface HTMLIonChipButtonElement extends IonChipButton, HTMLElement {
|
|
}
|
|
declare var HTMLIonChipButtonElement: {
|
|
prototype: HTMLIonChipButtonElement;
|
|
new (): HTMLIonChipButtonElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-chip-button": HTMLIonChipButtonElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-chip-button": HTMLIonChipButtonElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-chip-button": JSXElements.IonChipButtonAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonChipButtonAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
href?: string,
|
|
clear?: boolean,
|
|
disabled?: boolean
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Chip as IonChip } from './components/chip/chip';
|
|
|
|
interface HTMLIonChipElement extends IonChip, HTMLElement {
|
|
}
|
|
declare var HTMLIonChipElement: {
|
|
prototype: HTMLIonChipElement;
|
|
new (): HTMLIonChipElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-chip": HTMLIonChipElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-chip": HTMLIonChipElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-chip": JSXElements.IonChipAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonChipAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Content as IonContent } from './components/content/content';
|
|
|
|
interface HTMLIonContentElement extends IonContent, HTMLElement {
|
|
}
|
|
declare var HTMLIonContentElement: {
|
|
prototype: HTMLIonContentElement;
|
|
new (): HTMLIonContentElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-content": HTMLIonContentElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-content": HTMLIonContentElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-content": JSXElements.IonContentAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonContentAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
enableJsScroll?: any,
|
|
scrollToTop?: any,
|
|
scrollToBottom?: any,
|
|
ionScrollStart?: any,
|
|
ionScroll?: any,
|
|
ionScrollEnd?: any,
|
|
fullscreen?: boolean
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Datetime as IonDatetime } from './components/datetime/datetime';
|
|
|
|
interface HTMLIonDatetimeElement extends IonDatetime, HTMLElement {
|
|
}
|
|
declare var HTMLIonDatetimeElement: {
|
|
prototype: HTMLIonDatetimeElement;
|
|
new (): HTMLIonDatetimeElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-datetime": HTMLIonDatetimeElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-datetime": HTMLIonDatetimeElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-datetime": JSXElements.IonDatetimeAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonDatetimeAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
pickerCtrl?: any,
|
|
disabled?: boolean,
|
|
min?: string,
|
|
max?: string,
|
|
displayFormat?: string,
|
|
pickerFormat?: string,
|
|
cancelText?: string,
|
|
doneText?: string,
|
|
yearValues?: any,
|
|
monthValues?: any,
|
|
dayValues?: any,
|
|
hourValues?: any,
|
|
minuteValues?: any,
|
|
monthNames?: any,
|
|
monthShortNames?: any,
|
|
dayNames?: any,
|
|
dayShortNames?: any,
|
|
pickerOptions?: any,
|
|
placeholder?: string,
|
|
value?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { FabContainer as IonFab } from './components/fab/fab-container';
|
|
|
|
interface HTMLIonFabElement extends IonFab, HTMLElement {
|
|
}
|
|
declare var HTMLIonFabElement: {
|
|
prototype: HTMLIonFabElement;
|
|
new (): HTMLIonFabElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-fab": HTMLIonFabElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-fab": HTMLIonFabElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-fab": JSXElements.IonFabAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonFabAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
close?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { FabList as IonFabList } from './components/fab/fab-list';
|
|
|
|
interface HTMLIonFabListElement extends IonFabList, HTMLElement {
|
|
}
|
|
declare var HTMLIonFabListElement: {
|
|
prototype: HTMLIonFabListElement;
|
|
new (): HTMLIonFabListElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-fab-list": HTMLIonFabListElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-fab-list": HTMLIonFabListElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-fab-list": JSXElements.IonFabListAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonFabListAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
activated?: boolean
|
|
}
|
|
}
|
|
}
|
|
|
|
import { FabButton as IonFabButton } from './components/fab/fab';
|
|
|
|
interface HTMLIonFabButtonElement extends IonFabButton, HTMLElement {
|
|
}
|
|
declare var HTMLIonFabButtonElement: {
|
|
prototype: HTMLIonFabButtonElement;
|
|
new (): HTMLIonFabButtonElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-fab-button": HTMLIonFabButtonElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-fab-button": HTMLIonFabButtonElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-fab-button": JSXElements.IonFabButtonAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonFabButtonAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
href?: string,
|
|
activated?: boolean,
|
|
toggleActive?: any,
|
|
show?: boolean,
|
|
disabled?: boolean
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Footer as IonFooter } from './components/footer/footer';
|
|
|
|
interface HTMLIonFooterElement extends IonFooter, HTMLElement {
|
|
}
|
|
declare var HTMLIonFooterElement: {
|
|
prototype: HTMLIonFooterElement;
|
|
new (): HTMLIonFooterElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-footer": HTMLIonFooterElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-footer": HTMLIonFooterElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-footer": JSXElements.IonFooterAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonFooterAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { GestureController as IonGestureController } from './components/gesture-controller/gesture-controller';
|
|
|
|
interface HTMLIonGestureControllerElement extends IonGestureController, HTMLElement {
|
|
}
|
|
declare var HTMLIonGestureControllerElement: {
|
|
prototype: HTMLIonGestureControllerElement;
|
|
new (): HTMLIonGestureControllerElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-gesture-controller": HTMLIonGestureControllerElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-gesture-controller": HTMLIonGestureControllerElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-gesture-controller": JSXElements.IonGestureControllerAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonGestureControllerAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Gesture as IonGesture } from './components/gesture/gesture';
|
|
|
|
interface HTMLIonGestureElement extends IonGesture, HTMLElement {
|
|
}
|
|
declare var HTMLIonGestureElement: {
|
|
prototype: HTMLIonGestureElement;
|
|
new (): HTMLIonGestureElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-gesture": HTMLIonGestureElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-gesture": HTMLIonGestureElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-gesture": JSXElements.IonGestureAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonGestureAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
enabled?: boolean,
|
|
attachTo?: string,
|
|
autoBlockAll?: boolean,
|
|
block?: string,
|
|
disableScroll?: boolean,
|
|
direction?: string,
|
|
gestureName?: string,
|
|
gesturePriority?: number,
|
|
maxAngle?: number,
|
|
threshold?: number,
|
|
type?: string,
|
|
canStart?: any,
|
|
onWillStart?: any,
|
|
onStart?: any,
|
|
onMove?: any,
|
|
onEnd?: any,
|
|
onPress?: any,
|
|
notCaptured?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Col as IonCol } from './components/grid/col';
|
|
|
|
interface HTMLIonColElement extends IonCol, HTMLElement {
|
|
}
|
|
declare var HTMLIonColElement: {
|
|
prototype: HTMLIonColElement;
|
|
new (): HTMLIonColElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-col": HTMLIonColElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-col": HTMLIonColElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-col": JSXElements.IonColAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonColAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Grid as IonGrid } from './components/grid/grid';
|
|
|
|
interface HTMLIonGridElement extends IonGrid, HTMLElement {
|
|
}
|
|
declare var HTMLIonGridElement: {
|
|
prototype: HTMLIonGridElement;
|
|
new (): HTMLIonGridElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-grid": HTMLIonGridElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-grid": HTMLIonGridElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-grid": JSXElements.IonGridAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonGridAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Row as IonRow } from './components/grid/row';
|
|
|
|
interface HTMLIonRowElement extends IonRow, HTMLElement {
|
|
}
|
|
declare var HTMLIonRowElement: {
|
|
prototype: HTMLIonRowElement;
|
|
new (): HTMLIonRowElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-row": HTMLIonRowElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-row": HTMLIonRowElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-row": JSXElements.IonRowAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonRowAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Header as IonHeader } from './components/header/header';
|
|
|
|
interface HTMLIonHeaderElement extends IonHeader, HTMLElement {
|
|
}
|
|
declare var HTMLIonHeaderElement: {
|
|
prototype: HTMLIonHeaderElement;
|
|
new (): HTMLIonHeaderElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-header": HTMLIonHeaderElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-header": HTMLIonHeaderElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-header": JSXElements.IonHeaderAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonHeaderAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { InfiniteScrollContent as IonInfiniteScrollContent } from './components/infinite-scroll/infinite-scroll-content';
|
|
|
|
interface HTMLIonInfiniteScrollContentElement extends IonInfiniteScrollContent, HTMLElement {
|
|
}
|
|
declare var HTMLIonInfiniteScrollContentElement: {
|
|
prototype: HTMLIonInfiniteScrollContentElement;
|
|
new (): HTMLIonInfiniteScrollContentElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-infinite-scroll-content": HTMLIonInfiniteScrollContentElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-infinite-scroll-content": HTMLIonInfiniteScrollContentElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-infinite-scroll-content": JSXElements.IonInfiniteScrollContentAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonInfiniteScrollContentAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
loadingSpinner?: string,
|
|
loadingText?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { InfiniteScroll as IonInfiniteScroll } from './components/infinite-scroll/infinite-scroll';
|
|
|
|
interface HTMLIonInfiniteScrollElement extends IonInfiniteScroll, HTMLElement {
|
|
}
|
|
declare var HTMLIonInfiniteScrollElement: {
|
|
prototype: HTMLIonInfiniteScrollElement;
|
|
new (): HTMLIonInfiniteScrollElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-infinite-scroll": HTMLIonInfiniteScrollElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-infinite-scroll": HTMLIonInfiniteScrollElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-infinite-scroll": JSXElements.IonInfiniteScrollAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonInfiniteScrollAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
complete?: any,
|
|
threshold?: string,
|
|
enabled?: boolean,
|
|
position?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Input as IonInput } from './components/input/input';
|
|
|
|
interface HTMLIonInputElement extends IonInput, HTMLElement {
|
|
}
|
|
declare var HTMLIonInputElement: {
|
|
prototype: HTMLIonInputElement;
|
|
new (): HTMLIonInputElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-input": HTMLIonInputElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-input": HTMLIonInputElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-input": JSXElements.IonInputAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonInputAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
accept?: string,
|
|
autocapitalize?: string,
|
|
autocomplete?: string,
|
|
autocorrect?: string,
|
|
autofocus?: boolean,
|
|
checked?: boolean,
|
|
clearInput?: boolean,
|
|
clearOnEdit?: boolean,
|
|
disabled?: boolean,
|
|
inputmode?: string,
|
|
max?: string,
|
|
maxlength?: number,
|
|
min?: string,
|
|
minlength?: number,
|
|
multiple?: boolean,
|
|
name?: string,
|
|
pattern?: string,
|
|
placeholder?: string,
|
|
readonly?: boolean,
|
|
required?: boolean,
|
|
results?: number,
|
|
spellcheck?: boolean,
|
|
step?: string,
|
|
size?: number,
|
|
type?: string,
|
|
value?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Textarea as IonTextarea } from './components/input/textarea';
|
|
|
|
interface HTMLIonTextareaElement extends IonTextarea, HTMLElement {
|
|
}
|
|
declare var HTMLIonTextareaElement: {
|
|
prototype: HTMLIonTextareaElement;
|
|
new (): HTMLIonTextareaElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-textarea": HTMLIonTextareaElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-textarea": HTMLIonTextareaElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-textarea": JSXElements.IonTextareaAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonTextareaAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
autocapitalize?: string,
|
|
autocomplete?: string,
|
|
autofocus?: boolean,
|
|
clearOnEdit?: boolean,
|
|
disabled?: boolean,
|
|
maxlength?: number,
|
|
minlength?: number,
|
|
name?: string,
|
|
placeholder?: string,
|
|
readonly?: boolean,
|
|
required?: boolean,
|
|
spellcheck?: boolean,
|
|
cols?: number,
|
|
rows?: number,
|
|
wrap?: string,
|
|
value?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { ItemDivider as IonItemDivider } from './components/item-divider/item-divider';
|
|
|
|
interface HTMLIonItemDividerElement extends IonItemDivider, HTMLElement {
|
|
}
|
|
declare var HTMLIonItemDividerElement: {
|
|
prototype: HTMLIonItemDividerElement;
|
|
new (): HTMLIonItemDividerElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-item-divider": HTMLIonItemDividerElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-item-divider": HTMLIonItemDividerElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-item-divider": JSXElements.IonItemDividerAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonItemDividerAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { ItemOption as IonItemOption } from './components/item-sliding/item-option';
|
|
|
|
interface HTMLIonItemOptionElement extends IonItemOption, HTMLElement {
|
|
}
|
|
declare var HTMLIonItemOptionElement: {
|
|
prototype: HTMLIonItemOptionElement;
|
|
new (): HTMLIonItemOptionElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-item-option": HTMLIonItemOptionElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-item-option": HTMLIonItemOptionElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-item-option": JSXElements.IonItemOptionAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonItemOptionAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
href?: string,
|
|
disabled?: boolean
|
|
}
|
|
}
|
|
}
|
|
|
|
import { ItemOptions as IonItemOptions } from './components/item-sliding/item-options';
|
|
|
|
interface HTMLIonItemOptionsElement extends IonItemOptions, HTMLElement {
|
|
}
|
|
declare var HTMLIonItemOptionsElement: {
|
|
prototype: HTMLIonItemOptionsElement;
|
|
new (): HTMLIonItemOptionsElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-item-options": HTMLIonItemOptionsElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-item-options": HTMLIonItemOptionsElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-item-options": JSXElements.IonItemOptionsAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonItemOptionsAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
isRightSide?: any,
|
|
width?: any,
|
|
side?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { ItemSliding as IonItemSliding } from './components/item-sliding/item-sliding';
|
|
|
|
interface HTMLIonItemSlidingElement extends IonItemSliding, HTMLElement {
|
|
}
|
|
declare var HTMLIonItemSlidingElement: {
|
|
prototype: HTMLIonItemSlidingElement;
|
|
new (): HTMLIonItemSlidingElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-item-sliding": HTMLIonItemSlidingElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-item-sliding": HTMLIonItemSlidingElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-item-sliding": JSXElements.IonItemSlidingAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonItemSlidingAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
close?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Item as IonItem } from './components/item/item';
|
|
|
|
interface HTMLIonItemElement extends IonItem, HTMLElement {
|
|
}
|
|
declare var HTMLIonItemElement: {
|
|
prototype: HTMLIonItemElement;
|
|
new (): HTMLIonItemElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-item": HTMLIonItemElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-item": HTMLIonItemElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-item": JSXElements.IonItemAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonItemAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
getLabelText?: any,
|
|
href?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { IonKeyboardController as IonKeyboardController } from './components/keyboard-controller/keyboard-controller';
|
|
|
|
interface HTMLIonKeyboardControllerElement extends IonKeyboardController, HTMLElement {
|
|
}
|
|
declare var HTMLIonKeyboardControllerElement: {
|
|
prototype: HTMLIonKeyboardControllerElement;
|
|
new (): HTMLIonKeyboardControllerElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-keyboard-controller": HTMLIonKeyboardControllerElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-keyboard-controller": HTMLIonKeyboardControllerElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-keyboard-controller": JSXElements.IonKeyboardControllerAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonKeyboardControllerAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Label as IonLabel } from './components/label/label';
|
|
|
|
interface HTMLIonLabelElement extends IonLabel, HTMLElement {
|
|
}
|
|
declare var HTMLIonLabelElement: {
|
|
prototype: HTMLIonLabelElement;
|
|
new (): HTMLIonLabelElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-label": HTMLIonLabelElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-label": HTMLIonLabelElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-label": JSXElements.IonLabelAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonLabelAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
getText?: any,
|
|
fixed?: boolean,
|
|
floating?: boolean,
|
|
stacked?: boolean
|
|
}
|
|
}
|
|
}
|
|
|
|
import { ListHeader as IonListHeader } from './components/list-header/list-header';
|
|
|
|
interface HTMLIonListHeaderElement extends IonListHeader, HTMLElement {
|
|
}
|
|
declare var HTMLIonListHeaderElement: {
|
|
prototype: HTMLIonListHeaderElement;
|
|
new (): HTMLIonListHeaderElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-list-header": HTMLIonListHeaderElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-list-header": HTMLIonListHeaderElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-list-header": JSXElements.IonListHeaderAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonListHeaderAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { List as IonList } from './components/list/list';
|
|
|
|
interface HTMLIonListElement extends IonList, HTMLElement {
|
|
}
|
|
declare var HTMLIonListElement: {
|
|
prototype: HTMLIonListElement;
|
|
new (): HTMLIonListElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-list": HTMLIonListElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-list": HTMLIonListElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-list": JSXElements.IonListAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonListAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
getOpenedItem?: any,
|
|
setOpenedItem?: any,
|
|
closeSlidingItems?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { LoadingController as IonLoadingController } from './components/loading-controller/loading-controller';
|
|
|
|
interface HTMLIonLoadingControllerElement extends IonLoadingController, HTMLElement {
|
|
}
|
|
declare var HTMLIonLoadingControllerElement: {
|
|
prototype: HTMLIonLoadingControllerElement;
|
|
new (): HTMLIonLoadingControllerElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-loading-controller": HTMLIonLoadingControllerElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-loading-controller": HTMLIonLoadingControllerElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-loading-controller": JSXElements.IonLoadingControllerAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonLoadingControllerAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
create?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Loading as IonLoading } from './components/loading/loading';
|
|
|
|
interface HTMLIonLoadingElement extends IonLoading, HTMLElement {
|
|
}
|
|
declare var HTMLIonLoadingElement: {
|
|
prototype: HTMLIonLoadingElement;
|
|
new (): HTMLIonLoadingElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-loading": HTMLIonLoadingElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-loading": HTMLIonLoadingElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-loading": JSXElements.IonLoadingAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonLoadingAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
animationCtrl?: any,
|
|
cssClass?: string,
|
|
content?: string,
|
|
dismissOnPageChange?: boolean,
|
|
duration?: number,
|
|
enterAnimation?: any,
|
|
exitAnimation?: any,
|
|
loadingId?: string,
|
|
showBackdrop?: boolean
|
|
}
|
|
}
|
|
}
|
|
|
|
import { MenuController as IonMenuController } from './components/menu/menu-controller';
|
|
|
|
interface HTMLIonMenuControllerElement extends IonMenuController, HTMLElement {
|
|
}
|
|
declare var HTMLIonMenuControllerElement: {
|
|
prototype: HTMLIonMenuControllerElement;
|
|
new (): HTMLIonMenuControllerElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-menu-controller": HTMLIonMenuControllerElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-menu-controller": HTMLIonMenuControllerElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-menu-controller": JSXElements.IonMenuControllerAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonMenuControllerAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
open?: any,
|
|
close?: any,
|
|
toggle?: any,
|
|
enable?: any,
|
|
swipeEnable?: any,
|
|
isOpen?: any,
|
|
isEnabled?: any,
|
|
get?: any,
|
|
getOpen?: any,
|
|
getMenus?: any,
|
|
isAnimating?: any,
|
|
_register?: any,
|
|
_unregister?: any,
|
|
_setActiveMenu?: any,
|
|
createAnimation?: any,
|
|
animationCtrl?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Menu as IonMenu } from './components/menu/menu';
|
|
|
|
interface HTMLIonMenuElement extends IonMenu, HTMLElement {
|
|
}
|
|
declare var HTMLIonMenuElement: {
|
|
prototype: HTMLIonMenuElement;
|
|
new (): HTMLIonMenuElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-menu": HTMLIonMenuElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-menu": HTMLIonMenuElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-menu": JSXElements.IonMenuAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonMenuAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
isOpen?: any,
|
|
setOpen?: any,
|
|
open?: any,
|
|
close?: any,
|
|
toggle?: any,
|
|
lazyMenuCtrl?: any,
|
|
content?: string,
|
|
menuId?: string,
|
|
type?: string,
|
|
enabled?: boolean,
|
|
side?: string,
|
|
swipeEnabled?: boolean,
|
|
persistent?: boolean,
|
|
maxEdgeStart?: number
|
|
}
|
|
}
|
|
}
|
|
|
|
import { ModalController as IonModalController } from './components/modal-controller/modal-controller';
|
|
|
|
interface HTMLIonModalControllerElement extends IonModalController, HTMLElement {
|
|
}
|
|
declare var HTMLIonModalControllerElement: {
|
|
prototype: HTMLIonModalControllerElement;
|
|
new (): HTMLIonModalControllerElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-modal-controller": HTMLIonModalControllerElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-modal-controller": HTMLIonModalControllerElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-modal-controller": JSXElements.IonModalControllerAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonModalControllerAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
create?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Modal as IonModal } from './components/modal/modal';
|
|
|
|
interface HTMLIonModalElement extends IonModal, HTMLElement {
|
|
}
|
|
declare var HTMLIonModalElement: {
|
|
prototype: HTMLIonModalElement;
|
|
new (): HTMLIonModalElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-modal": HTMLIonModalElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-modal": HTMLIonModalElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-modal": JSXElements.IonModalAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonModalAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
animationCtrl?: any,
|
|
component?: string,
|
|
componentProps?: any,
|
|
cssClass?: string,
|
|
enableBackdropDismiss?: boolean,
|
|
enterAnimation?: any,
|
|
exitAnimation?: any,
|
|
modalId?: string,
|
|
showBackdrop?: boolean
|
|
}
|
|
}
|
|
}
|
|
|
|
import { NavControllerImpl as IonNavController } from './components/nav-controller/nav-controller';
|
|
|
|
interface HTMLIonNavControllerElement extends IonNavController, HTMLElement {
|
|
}
|
|
declare var HTMLIonNavControllerElement: {
|
|
prototype: HTMLIonNavControllerElement;
|
|
new (): HTMLIonNavControllerElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-nav-controller": HTMLIonNavControllerElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-nav-controller": HTMLIonNavControllerElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-nav-controller": JSXElements.IonNavControllerAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonNavControllerAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
push?: any,
|
|
pop?: any,
|
|
setRoot?: any,
|
|
insert?: any,
|
|
insertPages?: any,
|
|
popToRoot?: any,
|
|
popTo?: any,
|
|
removeIndex?: any,
|
|
removeView?: any,
|
|
setPages?: any,
|
|
delegate?: any,
|
|
animationCtrl?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { StencilNavDelegate as StencilIonNavDelegate } from './components/nav-controller/stencil-nav-delegate';
|
|
|
|
interface HTMLStencilIonNavDelegateElement extends StencilIonNavDelegate, HTMLElement {
|
|
}
|
|
declare var HTMLStencilIonNavDelegateElement: {
|
|
prototype: HTMLStencilIonNavDelegateElement;
|
|
new (): HTMLStencilIonNavDelegateElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"stencil-ion-nav-delegate": HTMLStencilIonNavDelegateElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"stencil-ion-nav-delegate": HTMLStencilIonNavDelegateElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"stencil-ion-nav-delegate": JSXElements.StencilIonNavDelegateAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface StencilIonNavDelegateAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
attachViewToDom?: any,
|
|
removeViewFromDom?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { IonNav as IonNav } from './components/nav/nav';
|
|
|
|
interface HTMLIonNavElement extends IonNav, HTMLElement {
|
|
}
|
|
declare var HTMLIonNavElement: {
|
|
prototype: HTMLIonNavElement;
|
|
new (): HTMLIonNavElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-nav": HTMLIonNavElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-nav": HTMLIonNavElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-nav": JSXElements.IonNavAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonNavAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
push?: any,
|
|
pop?: any,
|
|
setRoot?: any,
|
|
insert?: any,
|
|
insertPages?: any,
|
|
popToRoot?: any,
|
|
popTo?: any,
|
|
removeIndex?: any,
|
|
removeView?: any,
|
|
setPages?: any,
|
|
getActive?: any,
|
|
getPrevious?: any,
|
|
canGoBack?: any,
|
|
canSwipeBack?: any,
|
|
getFirstView?: any,
|
|
root?: any,
|
|
delegate?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { PageOne as PageOne } from './components/nav/page-one';
|
|
|
|
interface HTMLPageOneElement extends PageOne, HTMLElement {
|
|
}
|
|
declare var HTMLPageOneElement: {
|
|
prototype: HTMLPageOneElement;
|
|
new (): HTMLPageOneElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"page-one": HTMLPageOneElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"page-one": HTMLPageOneElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"page-one": JSXElements.PageOneAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface PageOneAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { PageThree as PageThree } from './components/nav/page-three';
|
|
|
|
interface HTMLPageThreeElement extends PageThree, HTMLElement {
|
|
}
|
|
declare var HTMLPageThreeElement: {
|
|
prototype: HTMLPageThreeElement;
|
|
new (): HTMLPageThreeElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"page-three": HTMLPageThreeElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"page-three": HTMLPageThreeElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"page-three": JSXElements.PageThreeAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface PageThreeAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { PageTwo as PageTwo } from './components/nav/page-two';
|
|
|
|
interface HTMLPageTwoElement extends PageTwo, HTMLElement {
|
|
}
|
|
declare var HTMLPageTwoElement: {
|
|
prototype: HTMLPageTwoElement;
|
|
new (): HTMLPageTwoElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"page-two": HTMLPageTwoElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"page-two": HTMLPageTwoElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"page-two": JSXElements.PageTwoAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface PageTwoAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Note as IonNote } from './components/note/note';
|
|
|
|
interface HTMLIonNoteElement extends IonNote, HTMLElement {
|
|
}
|
|
declare var HTMLIonNoteElement: {
|
|
prototype: HTMLIonNoteElement;
|
|
new (): HTMLIonNoteElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-note": HTMLIonNoteElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-note": HTMLIonNoteElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-note": JSXElements.IonNoteAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonNoteAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Page as IonPage } from './components/page/page';
|
|
|
|
interface HTMLIonPageElement extends IonPage, HTMLElement {
|
|
}
|
|
declare var HTMLIonPageElement: {
|
|
prototype: HTMLIonPageElement;
|
|
new (): HTMLIonPageElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-page": HTMLIonPageElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-page": HTMLIonPageElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-page": JSXElements.IonPageAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonPageAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { PickerController as IonPickerController } from './components/picker-controller/picker-controller';
|
|
|
|
interface HTMLIonPickerControllerElement extends IonPickerController, HTMLElement {
|
|
}
|
|
declare var HTMLIonPickerControllerElement: {
|
|
prototype: HTMLIonPickerControllerElement;
|
|
new (): HTMLIonPickerControllerElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-picker-controller": HTMLIonPickerControllerElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-picker-controller": HTMLIonPickerControllerElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-picker-controller": JSXElements.IonPickerControllerAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonPickerControllerAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
create?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { PickerColumnCmp as IonPickerColumn } from './components/picker/picker-column';
|
|
|
|
interface HTMLIonPickerColumnElement extends IonPickerColumn, HTMLElement {
|
|
}
|
|
declare var HTMLIonPickerColumnElement: {
|
|
prototype: HTMLIonPickerColumnElement;
|
|
new (): HTMLIonPickerColumnElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-picker-column": HTMLIonPickerColumnElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-picker-column": HTMLIonPickerColumnElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-picker-column": JSXElements.IonPickerColumnAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonPickerColumnAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
col?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Picker as IonPicker } from './components/picker/picker';
|
|
|
|
interface HTMLIonPickerElement extends IonPicker, HTMLElement {
|
|
}
|
|
declare var HTMLIonPickerElement: {
|
|
prototype: HTMLIonPickerElement;
|
|
new (): HTMLIonPickerElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-picker": HTMLIonPickerElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-picker": HTMLIonPickerElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-picker": JSXElements.IonPickerAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonPickerAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
addButton?: any,
|
|
addColumn?: any,
|
|
getColumn?: any,
|
|
getColumns?: any,
|
|
animationCtrl?: any,
|
|
cssClass?: string,
|
|
content?: string,
|
|
dismissOnPageChange?: boolean,
|
|
duration?: number,
|
|
enterAnimation?: any,
|
|
exitAnimation?: any,
|
|
pickerId?: string,
|
|
showBackdrop?: boolean,
|
|
enableBackdropDismiss?: boolean,
|
|
buttons?: any,
|
|
columns?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { PopoverController as IonPopoverController } from './components/popover-controller/popover-controller';
|
|
|
|
interface HTMLIonPopoverControllerElement extends IonPopoverController, HTMLElement {
|
|
}
|
|
declare var HTMLIonPopoverControllerElement: {
|
|
prototype: HTMLIonPopoverControllerElement;
|
|
new (): HTMLIonPopoverControllerElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-popover-controller": HTMLIonPopoverControllerElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-popover-controller": HTMLIonPopoverControllerElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-popover-controller": JSXElements.IonPopoverControllerAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonPopoverControllerAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
create?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Popover as IonPopover } from './components/popover/popover';
|
|
|
|
interface HTMLIonPopoverElement extends IonPopover, HTMLElement {
|
|
}
|
|
declare var HTMLIonPopoverElement: {
|
|
prototype: HTMLIonPopoverElement;
|
|
new (): HTMLIonPopoverElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-popover": HTMLIonPopoverElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-popover": HTMLIonPopoverElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-popover": JSXElements.IonPopoverAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonPopoverAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
animationCtrl?: any,
|
|
component?: string,
|
|
componentProps?: any,
|
|
cssClass?: string,
|
|
enableBackdropDismiss?: boolean,
|
|
enterAnimation?: any,
|
|
exitAnimation?: any,
|
|
ev?: any,
|
|
popoverId?: string,
|
|
showBackdrop?: boolean
|
|
}
|
|
}
|
|
}
|
|
|
|
import { RadioGroup as IonRadioGroup } from './components/radio/radio-group';
|
|
|
|
interface HTMLIonRadioGroupElement extends IonRadioGroup, HTMLElement {
|
|
}
|
|
declare var HTMLIonRadioGroupElement: {
|
|
prototype: HTMLIonRadioGroupElement;
|
|
new (): HTMLIonRadioGroupElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-radio-group": HTMLIonRadioGroupElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-radio-group": HTMLIonRadioGroupElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-radio-group": JSXElements.IonRadioGroupAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonRadioGroupAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
allowEmptySelection?: boolean,
|
|
disabled?: boolean,
|
|
value?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Radio as IonRadio } from './components/radio/radio';
|
|
|
|
interface HTMLIonRadioElement extends IonRadio, HTMLElement {
|
|
}
|
|
declare var HTMLIonRadioElement: {
|
|
prototype: HTMLIonRadioElement;
|
|
new (): HTMLIonRadioElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-radio": HTMLIonRadioElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-radio": HTMLIonRadioElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-radio": JSXElements.IonRadioAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonRadioAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
checked?: boolean,
|
|
disabled?: boolean,
|
|
value?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { RangeKnob as IonRangeKnob } from './components/range/range-knob';
|
|
|
|
interface HTMLIonRangeKnobElement extends IonRangeKnob, HTMLElement {
|
|
}
|
|
declare var HTMLIonRangeKnobElement: {
|
|
prototype: HTMLIonRangeKnobElement;
|
|
new (): HTMLIonRangeKnobElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-range-knob": HTMLIonRangeKnobElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-range-knob": HTMLIonRangeKnobElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-range-knob": JSXElements.IonRangeKnobAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonRangeKnobAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
pressed?: boolean,
|
|
pin?: boolean,
|
|
min?: number,
|
|
max?: number,
|
|
val?: number,
|
|
disabled?: boolean,
|
|
labelId?: string,
|
|
knob?: string,
|
|
ratio?: number
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Range as IonRange } from './components/range/range';
|
|
|
|
interface HTMLIonRangeElement extends IonRange, HTMLElement {
|
|
}
|
|
declare var HTMLIonRangeElement: {
|
|
prototype: HTMLIonRangeElement;
|
|
new (): HTMLIonRangeElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-range": HTMLIonRangeElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-range": HTMLIonRangeElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-range": JSXElements.IonRangeAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonRangeAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
ratio?: any,
|
|
ratioUpper?: any,
|
|
value?: any,
|
|
disabled?: boolean,
|
|
min?: number,
|
|
max?: number,
|
|
steps?: number,
|
|
dualKnobs?: boolean,
|
|
pin?: boolean,
|
|
snaps?: boolean,
|
|
debounce?: number
|
|
}
|
|
}
|
|
}
|
|
|
|
import { ReorderGroup as IonReorderGroup } from './components/reorder/reorder-group';
|
|
|
|
interface HTMLIonReorderGroupElement extends IonReorderGroup, HTMLElement {
|
|
}
|
|
declare var HTMLIonReorderGroupElement: {
|
|
prototype: HTMLIonReorderGroupElement;
|
|
new (): HTMLIonReorderGroupElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-reorder-group": HTMLIonReorderGroupElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-reorder-group": HTMLIonReorderGroupElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-reorder-group": JSXElements.IonReorderGroupAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonReorderGroupAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
enabled?: boolean
|
|
}
|
|
}
|
|
}
|
|
|
|
import { ItemReorder as IonReorder } from './components/reorder/reorder';
|
|
|
|
interface HTMLIonReorderElement extends IonReorder, HTMLElement {
|
|
}
|
|
declare var HTMLIonReorderElement: {
|
|
prototype: HTMLIonReorderElement;
|
|
new (): HTMLIonReorderElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-reorder": HTMLIonReorderElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-reorder": HTMLIonReorderElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-reorder": JSXElements.IonReorderAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonReorderAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { RouteLink as IonRouteLink } from './components/router/route-link';
|
|
|
|
interface HTMLIonRouteLinkElement extends IonRouteLink, HTMLElement {
|
|
}
|
|
declare var HTMLIonRouteLinkElement: {
|
|
prototype: HTMLIonRouteLinkElement;
|
|
new (): HTMLIonRouteLinkElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-route-link": HTMLIonRouteLinkElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-route-link": HTMLIonRouteLinkElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-route-link": JSXElements.IonRouteLinkAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonRouteLinkAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
url?: string,
|
|
router?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Route as IonRoute } from './components/router/route';
|
|
|
|
interface HTMLIonRouteElement extends IonRoute, HTMLElement {
|
|
}
|
|
declare var HTMLIonRouteElement: {
|
|
prototype: HTMLIonRouteElement;
|
|
new (): HTMLIonRouteElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-route": HTMLIonRouteElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-route": HTMLIonRouteElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-route": JSXElements.IonRouteAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonRouteAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
url?: string,
|
|
component?: string,
|
|
componentProps?: any,
|
|
router?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Router as IonRouter } from './components/router/router';
|
|
|
|
interface HTMLIonRouterElement extends IonRouter, HTMLElement {
|
|
}
|
|
declare var HTMLIonRouterElement: {
|
|
prototype: HTMLIonRouterElement;
|
|
new (): HTMLIonRouterElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-router": HTMLIonRouterElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-router": HTMLIonRouterElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-router": JSXElements.IonRouterAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonRouterAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
root?: string,
|
|
match?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Scroll as IonScroll } from './components/scroll/scroll';
|
|
|
|
interface HTMLIonScrollElement extends IonScroll, HTMLElement {
|
|
}
|
|
declare var HTMLIonScrollElement: {
|
|
prototype: HTMLIonScrollElement;
|
|
new (): HTMLIonScrollElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-scroll": HTMLIonScrollElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-scroll": HTMLIonScrollElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-scroll": JSXElements.IonScrollAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonScrollAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
scrollToTop?: any,
|
|
scrollToBottom?: any,
|
|
scrollToPoint?: any,
|
|
enabled?: boolean,
|
|
jsScroll?: boolean,
|
|
onionScrollStart?: any,
|
|
onionScroll?: any,
|
|
onionScrollEnd?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Searchbar as IonSearchbar } from './components/searchbar/searchbar';
|
|
|
|
interface HTMLIonSearchbarElement extends IonSearchbar, HTMLElement {
|
|
}
|
|
declare var HTMLIonSearchbarElement: {
|
|
prototype: HTMLIonSearchbarElement;
|
|
new (): HTMLIonSearchbarElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-searchbar": HTMLIonSearchbarElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-searchbar": HTMLIonSearchbarElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-searchbar": JSXElements.IonSearchbarAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonSearchbarAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
animated?: boolean,
|
|
autocomplete?: string,
|
|
autocorrect?: string,
|
|
cancelButtonText?: string,
|
|
debounce?: number,
|
|
placeholder?: string,
|
|
showCancelButton?: boolean,
|
|
spellcheck?: boolean,
|
|
type?: string,
|
|
value?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { SegmentButton as IonSegmentButton } from './components/segment-button/segment-button';
|
|
|
|
interface HTMLIonSegmentButtonElement extends IonSegmentButton, HTMLElement {
|
|
}
|
|
declare var HTMLIonSegmentButtonElement: {
|
|
prototype: HTMLIonSegmentButtonElement;
|
|
new (): HTMLIonSegmentButtonElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-segment-button": HTMLIonSegmentButtonElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-segment-button": HTMLIonSegmentButtonElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-segment-button": JSXElements.IonSegmentButtonAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonSegmentButtonAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
checked?: boolean,
|
|
disabled?: boolean,
|
|
value?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Segment as IonSegment } from './components/segment/segment';
|
|
|
|
interface HTMLIonSegmentElement extends IonSegment, HTMLElement {
|
|
}
|
|
declare var HTMLIonSegmentElement: {
|
|
prototype: HTMLIonSegmentElement;
|
|
new (): HTMLIonSegmentElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-segment": HTMLIonSegmentElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-segment": HTMLIonSegmentElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-segment": JSXElements.IonSegmentAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonSegmentAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
disabled?: boolean,
|
|
value?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { SelectOption as IonSelectOption } from './components/select-option/select-option';
|
|
|
|
interface HTMLIonSelectOptionElement extends IonSelectOption, HTMLElement {
|
|
}
|
|
declare var HTMLIonSelectOptionElement: {
|
|
prototype: HTMLIonSelectOptionElement;
|
|
new (): HTMLIonSelectOptionElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-select-option": HTMLIonSelectOptionElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-select-option": HTMLIonSelectOptionElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-select-option": JSXElements.IonSelectOptionAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonSelectOptionAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
getText?: any,
|
|
disabled?: boolean,
|
|
selected?: boolean,
|
|
value?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { SelectPopover as IonSelectPopover } from './components/select/select-popover';
|
|
|
|
interface HTMLIonSelectPopoverElement extends IonSelectPopover, HTMLElement {
|
|
}
|
|
declare var HTMLIonSelectPopoverElement: {
|
|
prototype: HTMLIonSelectPopoverElement;
|
|
new (): HTMLIonSelectPopoverElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-select-popover": HTMLIonSelectPopoverElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-select-popover": HTMLIonSelectPopoverElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-select-popover": JSXElements.IonSelectPopoverAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonSelectPopoverAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
options?: any,
|
|
value?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Select as IonSelect } from './components/select/select';
|
|
|
|
interface HTMLIonSelectElement extends IonSelect, HTMLElement {
|
|
}
|
|
declare var HTMLIonSelectElement: {
|
|
prototype: HTMLIonSelectElement;
|
|
new (): HTMLIonSelectElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-select": HTMLIonSelectElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-select": HTMLIonSelectElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-select": JSXElements.IonSelectAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonSelectAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
actionSheetCtrl?: any,
|
|
alertCtrl?: any,
|
|
popoverCtrl?: any,
|
|
disabled?: boolean,
|
|
cancelText?: string,
|
|
okText?: string,
|
|
placeholder?: string,
|
|
selectOptions?: any,
|
|
interface?: string,
|
|
selectedText?: string,
|
|
multiple?: boolean,
|
|
value?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { SkeletonText as IonSkeletonText } from './components/skeleton-text/skeleton-text';
|
|
|
|
interface HTMLIonSkeletonTextElement extends IonSkeletonText, HTMLElement {
|
|
}
|
|
declare var HTMLIonSkeletonTextElement: {
|
|
prototype: HTMLIonSkeletonTextElement;
|
|
new (): HTMLIonSkeletonTextElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-skeleton-text": HTMLIonSkeletonTextElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-skeleton-text": HTMLIonSkeletonTextElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-skeleton-text": JSXElements.IonSkeletonTextAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonSkeletonTextAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
width?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Slide as IonSlide } from './components/slides/slide';
|
|
|
|
interface HTMLIonSlideElement extends IonSlide, HTMLElement {
|
|
}
|
|
declare var HTMLIonSlideElement: {
|
|
prototype: HTMLIonSlideElement;
|
|
new (): HTMLIonSlideElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-slide": HTMLIonSlideElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-slide": HTMLIonSlideElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-slide": JSXElements.IonSlideAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonSlideAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Slides as IonSlides } from './components/slides/slides';
|
|
|
|
interface HTMLIonSlidesElement extends IonSlides, HTMLElement {
|
|
}
|
|
declare var HTMLIonSlidesElement: {
|
|
prototype: HTMLIonSlidesElement;
|
|
new (): HTMLIonSlidesElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-slides": HTMLIonSlidesElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-slides": HTMLIonSlidesElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-slides": JSXElements.IonSlidesAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonSlidesAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
effect?: string,
|
|
autoplay?: number,
|
|
control?: any,
|
|
direction?: string,
|
|
initialSlide?: number,
|
|
loop?: boolean,
|
|
pager?: boolean,
|
|
paginationType?: string,
|
|
parallax?: boolean,
|
|
slidesPerView?: number,
|
|
spaceBetween?: number,
|
|
speed?: number,
|
|
zoom?: boolean,
|
|
keyboardControl?: boolean
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Spinner as IonSpinner } from './components/spinner/spinner';
|
|
|
|
interface HTMLIonSpinnerElement extends IonSpinner, HTMLElement {
|
|
}
|
|
declare var HTMLIonSpinnerElement: {
|
|
prototype: HTMLIonSpinnerElement;
|
|
new (): HTMLIonSpinnerElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-spinner": HTMLIonSpinnerElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-spinner": HTMLIonSpinnerElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-spinner": JSXElements.IonSpinnerAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonSpinnerAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
duration?: number,
|
|
name?: string,
|
|
paused?: boolean
|
|
}
|
|
}
|
|
}
|
|
|
|
import { SplitPane as IonSplitPane } from './components/split-pane/split-pane';
|
|
|
|
interface HTMLIonSplitPaneElement extends IonSplitPane, HTMLElement {
|
|
}
|
|
declare var HTMLIonSplitPaneElement: {
|
|
prototype: HTMLIonSplitPaneElement;
|
|
new (): HTMLIonSplitPaneElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-split-pane": HTMLIonSplitPaneElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-split-pane": HTMLIonSplitPaneElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-split-pane": JSXElements.IonSplitPaneAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonSplitPaneAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
isVisible?: any,
|
|
enabled?: boolean,
|
|
when?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { TabBar as IonTabBar } from './components/tabs/tab-bar';
|
|
|
|
interface HTMLIonTabBarElement extends IonTabBar, HTMLElement {
|
|
}
|
|
declare var HTMLIonTabBarElement: {
|
|
prototype: HTMLIonTabBarElement;
|
|
new (): HTMLIonTabBarElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-tab-bar": HTMLIonTabBarElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-tab-bar": HTMLIonTabBarElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-tab-bar": JSXElements.IonTabBarAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonTabBarAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
tabs?: any,
|
|
onTabSelected?: any,
|
|
selectedIndex?: number,
|
|
tabsLayout?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { TabButton as IonTabButton } from './components/tabs/tab-button';
|
|
|
|
interface HTMLIonTabButtonElement extends IonTabButton, HTMLElement {
|
|
}
|
|
declare var HTMLIonTabButtonElement: {
|
|
prototype: HTMLIonTabButtonElement;
|
|
new (): HTMLIonTabButtonElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-tab-button": HTMLIonTabButtonElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-tab-button": HTMLIonTabButtonElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-tab-button": JSXElements.IonTabButtonAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonTabButtonAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
tab?: any,
|
|
layout?: string,
|
|
selectedIndex?: number,
|
|
index?: number
|
|
}
|
|
}
|
|
}
|
|
|
|
import { TabHighlight as IonTabHighlight } from './components/tabs/tab-highlight';
|
|
|
|
interface HTMLIonTabHighlightElement extends IonTabHighlight, HTMLElement {
|
|
}
|
|
declare var HTMLIonTabHighlightElement: {
|
|
prototype: HTMLIonTabHighlightElement;
|
|
new (): HTMLIonTabHighlightElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-tab-highlight": HTMLIonTabHighlightElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-tab-highlight": HTMLIonTabHighlightElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-tab-highlight": JSXElements.IonTabHighlightAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonTabHighlightAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Tab as IonTab } from './components/tabs/tab';
|
|
|
|
interface HTMLIonTabElement extends IonTab, HTMLElement {
|
|
}
|
|
declare var HTMLIonTabElement: {
|
|
prototype: HTMLIonTabElement;
|
|
new (): HTMLIonTabElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-tab": HTMLIonTabElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-tab": HTMLIonTabElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-tab": JSXElements.IonTabAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonTabAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
root?: string,
|
|
rootParams?: any,
|
|
tabTitle?: string,
|
|
tabIcon?: string,
|
|
tabBadge?: string,
|
|
tabBadgeStyle?: string,
|
|
enabled?: boolean,
|
|
shown?: boolean,
|
|
tabsHideOnSubPages?: boolean,
|
|
onSelected?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Tabs as IonTabs } from './components/tabs/tabs';
|
|
|
|
interface HTMLIonTabsElement extends IonTabs, HTMLElement {
|
|
}
|
|
declare var HTMLIonTabsElement: {
|
|
prototype: HTMLIonTabsElement;
|
|
new (): HTMLIonTabsElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-tabs": HTMLIonTabsElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-tabs": HTMLIonTabsElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-tabs": JSXElements.IonTabsAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonTabsAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
tabsLayout?: string,
|
|
tabsPlacement?: string,
|
|
tabsHighlight?: boolean,
|
|
ionChange?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Thumbnail as IonThumbnail } from './components/thumbnail/thumbnail';
|
|
|
|
interface HTMLIonThumbnailElement extends IonThumbnail, HTMLElement {
|
|
}
|
|
declare var HTMLIonThumbnailElement: {
|
|
prototype: HTMLIonThumbnailElement;
|
|
new (): HTMLIonThumbnailElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-thumbnail": HTMLIonThumbnailElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-thumbnail": HTMLIonThumbnailElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-thumbnail": JSXElements.IonThumbnailAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonThumbnailAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { ToolbarTitle as IonTitle } from './components/title/title';
|
|
|
|
interface HTMLIonTitleElement extends IonTitle, HTMLElement {
|
|
}
|
|
declare var HTMLIonTitleElement: {
|
|
prototype: HTMLIonTitleElement;
|
|
new (): HTMLIonTitleElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-title": HTMLIonTitleElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-title": HTMLIonTitleElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-title": JSXElements.IonTitleAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonTitleAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { ToastController as IonToastController } from './components/toast-controller/toast-controller';
|
|
|
|
interface HTMLIonToastControllerElement extends IonToastController, HTMLElement {
|
|
}
|
|
declare var HTMLIonToastControllerElement: {
|
|
prototype: HTMLIonToastControllerElement;
|
|
new (): HTMLIonToastControllerElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-toast-controller": HTMLIonToastControllerElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-toast-controller": HTMLIonToastControllerElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-toast-controller": JSXElements.IonToastControllerAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonToastControllerAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
create?: any
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Toast as IonToast } from './components/toast/toast';
|
|
|
|
interface HTMLIonToastElement extends IonToast, HTMLElement {
|
|
}
|
|
declare var HTMLIonToastElement: {
|
|
prototype: HTMLIonToastElement;
|
|
new (): HTMLIonToastElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-toast": HTMLIonToastElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-toast": HTMLIonToastElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-toast": JSXElements.IonToastAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonToastAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
animationCtrl?: any,
|
|
message?: string,
|
|
cssClass?: string,
|
|
duration?: number,
|
|
showCloseButton?: boolean,
|
|
closeButtonText?: string,
|
|
dismissOnPageChange?: boolean,
|
|
position?: string,
|
|
enterAnimation?: any,
|
|
exitAnimation?: any,
|
|
toastId?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Toggle as IonToggle } from './components/toggle/toggle';
|
|
|
|
interface HTMLIonToggleElement extends IonToggle, HTMLElement {
|
|
}
|
|
declare var HTMLIonToggleElement: {
|
|
prototype: HTMLIonToggleElement;
|
|
new (): HTMLIonToggleElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-toggle": HTMLIonToggleElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-toggle": HTMLIonToggleElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-toggle": JSXElements.IonToggleAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonToggleAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
checked?: boolean,
|
|
disabled?: boolean,
|
|
value?: string
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Navbar as IonNavbar } from './components/toolbar/navbar';
|
|
|
|
interface HTMLIonNavbarElement extends IonNavbar, HTMLElement {
|
|
}
|
|
declare var HTMLIonNavbarElement: {
|
|
prototype: HTMLIonNavbarElement;
|
|
new (): HTMLIonNavbarElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-navbar": HTMLIonNavbarElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-navbar": HTMLIonNavbarElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-navbar": JSXElements.IonNavbarAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonNavbarAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
hideBackButton?: boolean,
|
|
backButtonText?: string,
|
|
backButtonIcon?: string,
|
|
hidden?: boolean
|
|
}
|
|
}
|
|
}
|
|
|
|
import { Toolbar as IonToolbar } from './components/toolbar/toolbar';
|
|
|
|
interface HTMLIonToolbarElement extends IonToolbar, HTMLElement {
|
|
}
|
|
declare var HTMLIonToolbarElement: {
|
|
prototype: HTMLIonToolbarElement;
|
|
new (): HTMLIonToolbarElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-toolbar": HTMLIonToolbarElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-toolbar": HTMLIonToolbarElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-toolbar": JSXElements.IonToolbarAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonToolbarAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
import { IonUtils as IonUtils } from './components/util/util';
|
|
|
|
interface HTMLIonUtilsElement extends IonUtils, HTMLElement {
|
|
}
|
|
declare var HTMLIonUtilsElement: {
|
|
prototype: HTMLIonUtilsElement;
|
|
new (): HTMLIonUtilsElement;
|
|
};
|
|
declare global {
|
|
interface HTMLElementTagNameMap {
|
|
"ion-utils": HTMLIonUtilsElement;
|
|
}
|
|
interface ElementTagNameMap {
|
|
"ion-utils": HTMLIonUtilsElement;
|
|
}
|
|
namespace JSX {
|
|
interface IntrinsicElements {
|
|
"ion-utils": JSXElements.IonUtilsAttributes;
|
|
}
|
|
}
|
|
namespace JSXElements {
|
|
export interface IonUtilsAttributes extends HTMLAttributes {
|
|
mode?: string,
|
|
color?: string,
|
|
|
|
}
|
|
}
|
|
}
|
|
|