diff --git a/packages/core/src/components.d.ts b/packages/core/src/components.d.ts index 0047021b07..861990eebb 100644 --- a/packages/core/src/components.d.ts +++ b/packages/core/src/components.d.ts @@ -6,6 +6,589 @@ import 'ionicons'; +import { + ActionSheetButton, +} from './components/action-sheet/action-sheet'; +import { + AnimationBuilder, + FrameworkDelegate, + PickerColumn, + PickerOptions, +} from './index'; +import { + AlertButton, + AlertInput, +} from './components/alert/alert'; +import { + ElementRef, + Side, +} from './utils/helpers'; +import { + GestureCallback, + GestureDetail, +} from './components/gesture/gesture'; +import { + PickerButton, + PickerColumn as PickerColumn2, +} from './components/picker/picker'; +import { + Event, +} from '@stencil/core'; +import { + ScrollCallback, +} from './components/scroll/scroll'; +import { + SelectPopoverOption, +} from './components/select-popover/select-popover'; + +import { + ActionSheetController as IonActionSheetController +} from './components/action-sheet-controller/action-sheet-controller'; + +declare global { + interface HTMLIonActionSheetControllerElement extends IonActionSheetController, HTMLElement { + } + var HTMLIonActionSheetControllerElement: { + prototype: HTMLIonActionSheetControllerElement; + new (): HTMLIonActionSheetControllerElement; + }; + interface HTMLElementTagNameMap { + "ion-action-sheet-controller": HTMLIonActionSheetControllerElement; + } + interface ElementTagNameMap { + "ion-action-sheet-controller": HTMLIonActionSheetControllerElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-action-sheet-controller": JSXElements.IonActionSheetControllerAttributes; + } + } + namespace JSXElements { + export interface IonActionSheetControllerAttributes extends HTMLAttributes { + + } + } +} + + +import { + ActionSheet as IonActionSheet +} from './components/action-sheet/action-sheet'; + +declare global { + interface HTMLIonActionSheetElement extends IonActionSheet, HTMLElement { + } + var HTMLIonActionSheetElement: { + prototype: HTMLIonActionSheetElement; + new (): HTMLIonActionSheetElement; + }; + interface HTMLElementTagNameMap { + "ion-action-sheet": HTMLIonActionSheetElement; + } + interface ElementTagNameMap { + "ion-action-sheet": HTMLIonActionSheetElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-action-sheet": JSXElements.IonActionSheetAttributes; + } + } + namespace JSXElements { + export interface IonActionSheetAttributes extends HTMLAttributes { + buttons?: ActionSheetButton[]; + cssClass?: string; + enableBackdropDismiss?: boolean; + enterAnimation?: AnimationBuilder; + leaveAnimation?: AnimationBuilder; + subTitle?: string; + title?: string; + translucent?: boolean; + willAnimate?: boolean; + } + } +} + + +import { + AlertController as IonAlertController +} from './components/alert-controller/alert-controller'; + +declare global { + interface HTMLIonAlertControllerElement extends IonAlertController, HTMLElement { + } + var HTMLIonAlertControllerElement: { + prototype: HTMLIonAlertControllerElement; + new (): HTMLIonAlertControllerElement; + }; + interface HTMLElementTagNameMap { + "ion-alert-controller": HTMLIonAlertControllerElement; + } + interface ElementTagNameMap { + "ion-alert-controller": HTMLIonAlertControllerElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-alert-controller": JSXElements.IonAlertControllerAttributes; + } + } + namespace JSXElements { + export interface IonAlertControllerAttributes extends HTMLAttributes { + + } + } +} + + +import { + Alert as IonAlert +} from './components/alert/alert'; + +declare global { + interface HTMLIonAlertElement extends IonAlert, HTMLElement { + } + var HTMLIonAlertElement: { + prototype: HTMLIonAlertElement; + new (): HTMLIonAlertElement; + }; + interface HTMLElementTagNameMap { + "ion-alert": HTMLIonAlertElement; + } + interface ElementTagNameMap { + "ion-alert": HTMLIonAlertElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-alert": JSXElements.IonAlertAttributes; + } + } + namespace JSXElements { + export interface IonAlertAttributes extends HTMLAttributes { + buttons?: AlertButton[]; + cssClass?: string; + enableBackdropDismiss?: boolean; + enterAnimation?: AnimationBuilder; + inputs?: AlertInput[]; + leaveAnimation?: AnimationBuilder; + message?: string; + subTitle?: string; + title?: string; + translucent?: boolean; + willAnimate?: boolean; + } + } +} + + +import { + AnimationControllerImpl as IonAnimationController +} from './components/animation-controller/animation-controller'; + +declare global { + interface HTMLIonAnimationControllerElement extends IonAnimationController, HTMLElement { + } + var HTMLIonAnimationControllerElement: { + prototype: HTMLIonAnimationControllerElement; + new (): HTMLIonAnimationControllerElement; + }; + interface HTMLElementTagNameMap { + "ion-animation-controller": HTMLIonAnimationControllerElement; + } + interface ElementTagNameMap { + "ion-animation-controller": HTMLIonAnimationControllerElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-animation-controller": JSXElements.IonAnimationControllerAttributes; + } + } + namespace JSXElements { + export interface IonAnimationControllerAttributes extends HTMLAttributes { + + } + } +} + + +import { + App as IonApp +} from './components/app/app'; + +declare global { + interface HTMLIonAppElement extends IonApp, HTMLElement { + } + var HTMLIonAppElement: { + prototype: HTMLIonAppElement; + new (): HTMLIonAppElement; + }; + interface HTMLElementTagNameMap { + "ion-app": HTMLIonAppElement; + } + interface ElementTagNameMap { + "ion-app": HTMLIonAppElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-app": JSXElements.IonAppAttributes; + } + } + namespace JSXElements { + export interface IonAppAttributes extends HTMLAttributes { + + } + } +} + + +import { + Avatar as IonAvatar +} from './components/avatar/avatar'; + +declare global { + interface HTMLIonAvatarElement extends IonAvatar, HTMLElement { + } + var HTMLIonAvatarElement: { + prototype: HTMLIonAvatarElement; + new (): HTMLIonAvatarElement; + }; + interface HTMLElementTagNameMap { + "ion-avatar": HTMLIonAvatarElement; + } + interface ElementTagNameMap { + "ion-avatar": HTMLIonAvatarElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-avatar": JSXElements.IonAvatarAttributes; + } + } + namespace JSXElements { + export interface IonAvatarAttributes extends HTMLAttributes { + + } + } +} + + +import { + Backdrop as IonBackdrop +} from './components/backdrop/backdrop'; + +declare global { + interface HTMLIonBackdropElement extends IonBackdrop, HTMLElement { + } + var HTMLIonBackdropElement: { + prototype: HTMLIonBackdropElement; + new (): HTMLIonBackdropElement; + }; + interface HTMLElementTagNameMap { + "ion-backdrop": HTMLIonBackdropElement; + } + interface ElementTagNameMap { + "ion-backdrop": HTMLIonBackdropElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-backdrop": JSXElements.IonBackdropAttributes; + } + } + namespace JSXElements { + export interface IonBackdropAttributes extends HTMLAttributes { + + } + } +} + + +import { + Badge as IonBadge +} from './components/badge/badge'; + +declare global { + interface HTMLIonBadgeElement extends IonBadge, HTMLElement { + } + var HTMLIonBadgeElement: { + prototype: HTMLIonBadgeElement; + new (): HTMLIonBadgeElement; + }; + interface HTMLElementTagNameMap { + "ion-badge": HTMLIonBadgeElement; + } + interface ElementTagNameMap { + "ion-badge": HTMLIonBadgeElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-badge": JSXElements.IonBadgeAttributes; + } + } + namespace JSXElements { + export interface IonBadgeAttributes extends HTMLAttributes { + color?: string; + mode?: 'ios' | 'md'; + } + } +} + + +import { + Button as IonButton +} from './components/button/button'; + +declare global { + interface HTMLIonButtonElement extends IonButton, HTMLElement { + } + var HTMLIonButtonElement: { + prototype: HTMLIonButtonElement; + new (): HTMLIonButtonElement; + }; + interface HTMLElementTagNameMap { + "ion-button": HTMLIonButtonElement; + } + interface ElementTagNameMap { + "ion-button": HTMLIonButtonElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-button": JSXElements.IonButtonAttributes; + } + } + namespace JSXElements { + export interface IonButtonAttributes extends HTMLAttributes { + buttonType?: string; + color?: string; + disabled?: boolean; + expand?: 'full' | 'block'; + fill?: 'clear' | 'outline' | 'solid' | 'default'; + href?: string; + mode?: 'ios' | 'md'; + round?: boolean; + size?: 'small' | 'default' | 'large'; + strong?: boolean; + } + } +} + + +import { + Buttons as IonButtons +} from './components/buttons/buttons'; + +declare global { + interface HTMLIonButtonsElement extends IonButtons, HTMLElement { + } + var HTMLIonButtonsElement: { + prototype: HTMLIonButtonsElement; + new (): HTMLIonButtonsElement; + }; + interface HTMLElementTagNameMap { + "ion-buttons": HTMLIonButtonsElement; + } + interface ElementTagNameMap { + "ion-buttons": HTMLIonButtonsElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-buttons": JSXElements.IonButtonsAttributes; + } + } + namespace JSXElements { + export interface IonButtonsAttributes extends HTMLAttributes { + + } + } +} + + +import { + CardContent as IonCardContent +} from './components/card-content/card-content'; + +declare global { + interface HTMLIonCardContentElement extends IonCardContent, HTMLElement { + } + var HTMLIonCardContentElement: { + prototype: HTMLIonCardContentElement; + new (): HTMLIonCardContentElement; + }; + interface HTMLElementTagNameMap { + "ion-card-content": HTMLIonCardContentElement; + } + interface ElementTagNameMap { + "ion-card-content": HTMLIonCardContentElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-card-content": JSXElements.IonCardContentAttributes; + } + } + namespace JSXElements { + export interface IonCardContentAttributes extends HTMLAttributes { + color?: string; + mode?: 'ios' | 'md'; + } + } +} + + +import { + CardHeader as IonCardHeader +} from './components/card-header/card-header'; + +declare global { + interface HTMLIonCardHeaderElement extends IonCardHeader, HTMLElement { + } + var HTMLIonCardHeaderElement: { + prototype: HTMLIonCardHeaderElement; + new (): HTMLIonCardHeaderElement; + }; + interface HTMLElementTagNameMap { + "ion-card-header": HTMLIonCardHeaderElement; + } + interface ElementTagNameMap { + "ion-card-header": HTMLIonCardHeaderElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-card-header": JSXElements.IonCardHeaderAttributes; + } + } + namespace JSXElements { + export interface IonCardHeaderAttributes extends HTMLAttributes { + color?: string; + mode?: 'ios' | 'md'; + translucent?: boolean; + } + } +} + + +import { + CardSubtitle as IonCardSubtitle +} from './components/card-subtitle/card-subtitle'; + +declare global { + interface HTMLIonCardSubtitleElement extends IonCardSubtitle, HTMLElement { + } + var HTMLIonCardSubtitleElement: { + prototype: HTMLIonCardSubtitleElement; + new (): HTMLIonCardSubtitleElement; + }; + interface HTMLElementTagNameMap { + "ion-card-subtitle": HTMLIonCardSubtitleElement; + } + interface ElementTagNameMap { + "ion-card-subtitle": HTMLIonCardSubtitleElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-card-subtitle": JSXElements.IonCardSubtitleAttributes; + } + } + namespace JSXElements { + export interface IonCardSubtitleAttributes extends HTMLAttributes { + color?: string; + mode?: 'ios' | 'md'; + } + } +} + + +import { + CardTitle as IonCardTitle +} from './components/card-title/card-title'; + +declare global { + interface HTMLIonCardTitleElement extends IonCardTitle, HTMLElement { + } + var HTMLIonCardTitleElement: { + prototype: HTMLIonCardTitleElement; + new (): HTMLIonCardTitleElement; + }; + interface HTMLElementTagNameMap { + "ion-card-title": HTMLIonCardTitleElement; + } + interface ElementTagNameMap { + "ion-card-title": HTMLIonCardTitleElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-card-title": JSXElements.IonCardTitleAttributes; + } + } + namespace JSXElements { + export interface IonCardTitleAttributes extends HTMLAttributes { + color?: string; + mode?: 'ios' | 'md'; + } + } +} + + +import { + Card as IonCard +} from './components/card/card'; + +declare global { + interface HTMLIonCardElement extends IonCard, HTMLElement { + } + var HTMLIonCardElement: { + prototype: HTMLIonCardElement; + new (): HTMLIonCardElement; + }; + interface HTMLElementTagNameMap { + "ion-card": HTMLIonCardElement; + } + interface ElementTagNameMap { + "ion-card": HTMLIonCardElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-card": JSXElements.IonCardAttributes; + } + } + namespace JSXElements { + export interface IonCardAttributes extends HTMLAttributes { + color?: string; + mode?: 'ios' | 'md'; + } + } +} + + +import { + Checkbox as IonCheckbox +} from './components/checkbox/checkbox'; + +declare global { + interface HTMLIonCheckboxElement extends IonCheckbox, HTMLElement { + } + var HTMLIonCheckboxElement: { + prototype: HTMLIonCheckboxElement; + new (): HTMLIonCheckboxElement; + }; + interface HTMLElementTagNameMap { + "ion-checkbox": HTMLIonCheckboxElement; + } + interface ElementTagNameMap { + "ion-checkbox": HTMLIonCheckboxElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-checkbox": JSXElements.IonCheckboxAttributes; + } + } + namespace JSXElements { + export interface IonCheckboxAttributes extends HTMLAttributes { + checked?: boolean; + color?: string; + disabled?: boolean; + mode?: 'ios' | 'md'; + name?: string; + value?: string; + } + } +} + import { ChipButton as IonChipButton @@ -40,3 +623,2493 @@ declare global { } } + +import { + Chip as IonChip +} from './components/chip/chip'; + +declare global { + interface HTMLIonChipElement extends IonChip, HTMLElement { + } + var HTMLIonChipElement: { + prototype: HTMLIonChipElement; + new (): HTMLIonChipElement; + }; + interface HTMLElementTagNameMap { + "ion-chip": HTMLIonChipElement; + } + interface ElementTagNameMap { + "ion-chip": HTMLIonChipElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-chip": JSXElements.IonChipAttributes; + } + } + namespace JSXElements { + export interface IonChipAttributes extends HTMLAttributes { + color?: string; + mode?: 'ios' | 'md'; + } + } +} + + +import { + Col as IonCol +} from './components/col/col'; + +declare global { + interface HTMLIonColElement extends IonCol, HTMLElement { + } + var HTMLIonColElement: { + prototype: HTMLIonColElement; + new (): HTMLIonColElement; + }; + interface HTMLElementTagNameMap { + "ion-col": HTMLIonColElement; + } + interface ElementTagNameMap { + "ion-col": HTMLIonColElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-col": JSXElements.IonColAttributes; + } + } + namespace JSXElements { + export interface IonColAttributes extends HTMLAttributes { + + } + } +} + + +import { + Content as IonContent +} from './components/content/content'; + +declare global { + interface HTMLIonContentElement extends IonContent, HTMLElement { + } + var HTMLIonContentElement: { + prototype: HTMLIonContentElement; + new (): HTMLIonContentElement; + }; + interface HTMLElementTagNameMap { + "ion-content": HTMLIonContentElement; + } + interface ElementTagNameMap { + "ion-content": HTMLIonContentElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-content": JSXElements.IonContentAttributes; + } + } + namespace JSXElements { + export interface IonContentAttributes extends HTMLAttributes { + fullscreen?: boolean; + ionScroll?: Function; + ionScrollEnd?: Function; + ionScrollStart?: Function; + } + } +} + + +import { + Datetime as IonDatetime +} from './components/datetime/datetime'; + +declare global { + interface HTMLIonDatetimeElement extends IonDatetime, HTMLElement { + } + var HTMLIonDatetimeElement: { + prototype: HTMLIonDatetimeElement; + new (): HTMLIonDatetimeElement; + }; + interface HTMLElementTagNameMap { + "ion-datetime": HTMLIonDatetimeElement; + } + interface ElementTagNameMap { + "ion-datetime": HTMLIonDatetimeElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-datetime": JSXElements.IonDatetimeAttributes; + } + } + namespace JSXElements { + export interface IonDatetimeAttributes extends HTMLAttributes { + cancelText?: string; + dayNames?: any; + dayShortNames?: any; + dayValues?: any; + disabled?: boolean; + displayFormat?: string; + doneText?: string; + hourValues?: any; + max?: string; + min?: string; + minuteValues?: any; + monthNames?: any; + monthShortNames?: any; + monthValues?: any; + pickerFormat?: string; + pickerOptions?: PickerOptions; + placeholder?: string; + value?: string; + yearValues?: any; + } + } +} + + +import { + Events as IonEvents +} from './components/events/events'; + +declare global { + interface HTMLIonEventsElement extends IonEvents, HTMLElement { + } + var HTMLIonEventsElement: { + prototype: HTMLIonEventsElement; + new (): HTMLIonEventsElement; + }; + interface HTMLElementTagNameMap { + "ion-events": HTMLIonEventsElement; + } + interface ElementTagNameMap { + "ion-events": HTMLIonEventsElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-events": JSXElements.IonEventsAttributes; + } + } + namespace JSXElements { + export interface IonEventsAttributes extends HTMLAttributes { + + } + } +} + + +import { + FabButton as IonFabButton +} from './components/fab-button/fab-button'; + +declare global { + interface HTMLIonFabButtonElement extends IonFabButton, HTMLElement { + } + var HTMLIonFabButtonElement: { + prototype: HTMLIonFabButtonElement; + new (): HTMLIonFabButtonElement; + }; + interface HTMLElementTagNameMap { + "ion-fab-button": HTMLIonFabButtonElement; + } + interface ElementTagNameMap { + "ion-fab-button": HTMLIonFabButtonElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-fab-button": JSXElements.IonFabButtonAttributes; + } + } + namespace JSXElements { + export interface IonFabButtonAttributes extends HTMLAttributes { + activated?: boolean; + color?: string; + disabled?: boolean; + href?: string; + mode?: 'ios' | 'md'; + show?: boolean; + toggleActive?: Function; + translucent?: boolean; + } + } +} + + +import { + FabList as IonFabList +} from './components/fab-list/fab-list'; + +declare global { + interface HTMLIonFabListElement extends IonFabList, HTMLElement { + } + var HTMLIonFabListElement: { + prototype: HTMLIonFabListElement; + new (): HTMLIonFabListElement; + }; + interface HTMLElementTagNameMap { + "ion-fab-list": HTMLIonFabListElement; + } + interface ElementTagNameMap { + "ion-fab-list": HTMLIonFabListElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-fab-list": JSXElements.IonFabListAttributes; + } + } + namespace JSXElements { + export interface IonFabListAttributes extends HTMLAttributes { + activated?: boolean; + } + } +} + + +import { + Fab as IonFab +} from './components/fab/fab'; + +declare global { + interface HTMLIonFabElement extends IonFab, HTMLElement { + } + var HTMLIonFabElement: { + prototype: HTMLIonFabElement; + new (): HTMLIonFabElement; + }; + interface HTMLElementTagNameMap { + "ion-fab": HTMLIonFabElement; + } + interface ElementTagNameMap { + "ion-fab": HTMLIonFabElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-fab": JSXElements.IonFabAttributes; + } + } + namespace JSXElements { + export interface IonFabAttributes extends HTMLAttributes { + + } + } +} + + +import { + Footer as IonFooter +} from './components/footer/footer'; + +declare global { + interface HTMLIonFooterElement extends IonFooter, HTMLElement { + } + var HTMLIonFooterElement: { + prototype: HTMLIonFooterElement; + new (): HTMLIonFooterElement; + }; + interface HTMLElementTagNameMap { + "ion-footer": HTMLIonFooterElement; + } + interface ElementTagNameMap { + "ion-footer": HTMLIonFooterElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-footer": JSXElements.IonFooterAttributes; + } + } + namespace JSXElements { + export interface IonFooterAttributes extends HTMLAttributes { + translucent?: boolean; + } + } +} + + +import { + GestureController as IonGestureController +} from './components/gesture-controller/gesture-controller'; + +declare global { + interface HTMLIonGestureControllerElement extends IonGestureController, HTMLElement { + } + var HTMLIonGestureControllerElement: { + prototype: HTMLIonGestureControllerElement; + new (): HTMLIonGestureControllerElement; + }; + 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'; + +declare global { + interface HTMLIonGestureElement extends IonGesture, HTMLElement { + } + var HTMLIonGestureElement: { + prototype: HTMLIonGestureElement; + new (): HTMLIonGestureElement; + }; + interface HTMLElementTagNameMap { + "ion-gesture": HTMLIonGestureElement; + } + interface ElementTagNameMap { + "ion-gesture": HTMLIonGestureElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-gesture": JSXElements.IonGestureAttributes; + } + } + namespace JSXElements { + export interface IonGestureAttributes extends HTMLAttributes { + attachTo?: ElementRef; + autoBlockAll?: boolean; + block?: string; + canStart?: GestureCallback; + direction?: string; + disableScroll?: boolean; + enabled?: boolean; + gestureName?: string; + gesturePriority?: number; + maxAngle?: number; + notCaptured?: GestureCallback; + onEnd?: GestureCallback; + onMove?: GestureCallback; + onPress?: GestureCallback; + onStart?: GestureCallback; + onWillStart?: (_: GestureDetail) => Promise; + threshold?: number; + type?: string; + } + } +} + + +import { + Grid as IonGrid +} from './components/grid/grid'; + +declare global { + interface HTMLIonGridElement extends IonGrid, HTMLElement { + } + var HTMLIonGridElement: { + prototype: HTMLIonGridElement; + new (): HTMLIonGridElement; + }; + interface HTMLElementTagNameMap { + "ion-grid": HTMLIonGridElement; + } + interface ElementTagNameMap { + "ion-grid": HTMLIonGridElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-grid": JSXElements.IonGridAttributes; + } + } + namespace JSXElements { + export interface IonGridAttributes extends HTMLAttributes { + + } + } +} + + +import { + Header as IonHeader +} from './components/header/header'; + +declare global { + interface HTMLIonHeaderElement extends IonHeader, HTMLElement { + } + var HTMLIonHeaderElement: { + prototype: HTMLIonHeaderElement; + new (): HTMLIonHeaderElement; + }; + interface HTMLElementTagNameMap { + "ion-header": HTMLIonHeaderElement; + } + interface ElementTagNameMap { + "ion-header": HTMLIonHeaderElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-header": JSXElements.IonHeaderAttributes; + } + } + namespace JSXElements { + export interface IonHeaderAttributes extends HTMLAttributes { + translucent?: boolean; + } + } +} + + +import { + InfiniteScrollContent as IonInfiniteScrollContent +} from './components/infinite-scroll-content/infinite-scroll-content'; + +declare global { + interface HTMLIonInfiniteScrollContentElement extends IonInfiniteScrollContent, HTMLElement { + } + var HTMLIonInfiniteScrollContentElement: { + prototype: HTMLIonInfiniteScrollContentElement; + new (): HTMLIonInfiniteScrollContentElement; + }; + interface HTMLElementTagNameMap { + "ion-infinite-scroll-content": HTMLIonInfiniteScrollContentElement; + } + interface ElementTagNameMap { + "ion-infinite-scroll-content": HTMLIonInfiniteScrollContentElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-infinite-scroll-content": JSXElements.IonInfiniteScrollContentAttributes; + } + } + namespace JSXElements { + export interface IonInfiniteScrollContentAttributes extends HTMLAttributes { + loadingSpinner?: string; + loadingText?: string; + } + } +} + + +import { + InfiniteScroll as IonInfiniteScroll +} from './components/infinite-scroll/infinite-scroll'; + +declare global { + interface HTMLIonInfiniteScrollElement extends IonInfiniteScroll, HTMLElement { + } + var HTMLIonInfiniteScrollElement: { + prototype: HTMLIonInfiniteScrollElement; + new (): HTMLIonInfiniteScrollElement; + }; + interface HTMLElementTagNameMap { + "ion-infinite-scroll": HTMLIonInfiniteScrollElement; + } + interface ElementTagNameMap { + "ion-infinite-scroll": HTMLIonInfiniteScrollElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-infinite-scroll": JSXElements.IonInfiniteScrollAttributes; + } + } + namespace JSXElements { + export interface IonInfiniteScrollAttributes extends HTMLAttributes { + enabled?: boolean; + position?: string; + threshold?: string; + } + } +} + + +import { + Input as IonInput +} from './components/input/input'; + +declare global { + interface HTMLIonInputElement extends IonInput, HTMLElement { + } + var HTMLIonInputElement: { + prototype: HTMLIonInputElement; + new (): HTMLIonInputElement; + }; + interface HTMLElementTagNameMap { + "ion-input": HTMLIonInputElement; + } + interface ElementTagNameMap { + "ion-input": HTMLIonInputElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-input": JSXElements.IonInputAttributes; + } + } + namespace JSXElements { + export interface IonInputAttributes extends HTMLAttributes { + accept?: string; + autocapitalize?: string; + autocomplete?: string; + autocorrect?: string; + autofocus?: boolean; + checked?: boolean; + clearInput?: boolean; + clearOnEdit?: boolean; + debounce?: number; + disabled?: boolean; + inputmode?: string; + max?: string; + maxlength?: number; + min?: string; + minlength?: number; + multiple?: boolean; + name?: string; + pattern?: string; + placeholder?: string; + readonly?: boolean; + required?: boolean; + results?: number; + size?: number; + spellcheck?: boolean; + step?: string; + type?: string; + value?: string; + } + } +} + + +import { + ItemDivider as IonItemDivider +} from './components/item-divider/item-divider'; + +declare global { + interface HTMLIonItemDividerElement extends IonItemDivider, HTMLElement { + } + var HTMLIonItemDividerElement: { + prototype: HTMLIonItemDividerElement; + new (): HTMLIonItemDividerElement; + }; + interface HTMLElementTagNameMap { + "ion-item-divider": HTMLIonItemDividerElement; + } + interface ElementTagNameMap { + "ion-item-divider": HTMLIonItemDividerElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-item-divider": JSXElements.IonItemDividerAttributes; + } + } + namespace JSXElements { + export interface IonItemDividerAttributes extends HTMLAttributes { + color?: string; + mode?: 'ios' | 'md'; + } + } +} + + +import { + ItemGroup as IonItemGroup +} from './components/item-group/item-group'; + +declare global { + interface HTMLIonItemGroupElement extends IonItemGroup, HTMLElement { + } + var HTMLIonItemGroupElement: { + prototype: HTMLIonItemGroupElement; + new (): HTMLIonItemGroupElement; + }; + interface HTMLElementTagNameMap { + "ion-item-group": HTMLIonItemGroupElement; + } + interface ElementTagNameMap { + "ion-item-group": HTMLIonItemGroupElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-item-group": JSXElements.IonItemGroupAttributes; + } + } + namespace JSXElements { + export interface IonItemGroupAttributes extends HTMLAttributes { + + } + } +} + + +import { + ItemOption as IonItemOption +} from './components/item-option/item-option'; + +declare global { + interface HTMLIonItemOptionElement extends IonItemOption, HTMLElement { + } + var HTMLIonItemOptionElement: { + prototype: HTMLIonItemOptionElement; + new (): HTMLIonItemOptionElement; + }; + interface HTMLElementTagNameMap { + "ion-item-option": HTMLIonItemOptionElement; + } + interface ElementTagNameMap { + "ion-item-option": HTMLIonItemOptionElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-item-option": JSXElements.IonItemOptionAttributes; + } + } + namespace JSXElements { + export interface IonItemOptionAttributes extends HTMLAttributes { + color?: string; + disabled?: boolean; + href?: string; + mode?: 'ios' | 'md'; + } + } +} + + +import { + ItemOptions as IonItemOptions +} from './components/item-options/item-options'; + +declare global { + interface HTMLIonItemOptionsElement extends IonItemOptions, HTMLElement { + } + var HTMLIonItemOptionsElement: { + prototype: HTMLIonItemOptionsElement; + new (): HTMLIonItemOptionsElement; + }; + interface HTMLElementTagNameMap { + "ion-item-options": HTMLIonItemOptionsElement; + } + interface ElementTagNameMap { + "ion-item-options": HTMLIonItemOptionsElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-item-options": JSXElements.IonItemOptionsAttributes; + } + } + namespace JSXElements { + export interface IonItemOptionsAttributes extends HTMLAttributes { + side?: Side; + } + } +} + + +import { + ItemSliding as IonItemSliding +} from './components/item-sliding/item-sliding'; + +declare global { + interface HTMLIonItemSlidingElement extends IonItemSliding, HTMLElement { + } + var HTMLIonItemSlidingElement: { + prototype: HTMLIonItemSlidingElement; + new (): HTMLIonItemSlidingElement; + }; + interface HTMLElementTagNameMap { + "ion-item-sliding": HTMLIonItemSlidingElement; + } + interface ElementTagNameMap { + "ion-item-sliding": HTMLIonItemSlidingElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-item-sliding": JSXElements.IonItemSlidingAttributes; + } + } + namespace JSXElements { + export interface IonItemSlidingAttributes extends HTMLAttributes { + + } + } +} + + +import { + Item as IonItem +} from './components/item/item'; + +declare global { + interface HTMLIonItemElement extends IonItem, HTMLElement { + } + var HTMLIonItemElement: { + prototype: HTMLIonItemElement; + new (): HTMLIonItemElement; + }; + interface HTMLElementTagNameMap { + "ion-item": HTMLIonItemElement; + } + interface ElementTagNameMap { + "ion-item": HTMLIonItemElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-item": JSXElements.IonItemAttributes; + } + } + namespace JSXElements { + export interface IonItemAttributes extends HTMLAttributes { + color?: string; + href?: string; + mode?: 'ios' | 'md'; + } + } +} + + +import { + KeyboardController as IonKeyboardController +} from './components/keyboard-controller/keyboard-controller'; + +declare global { + interface HTMLIonKeyboardControllerElement extends IonKeyboardController, HTMLElement { + } + var HTMLIonKeyboardControllerElement: { + prototype: HTMLIonKeyboardControllerElement; + new (): HTMLIonKeyboardControllerElement; + }; + interface HTMLElementTagNameMap { + "ion-keyboard-controller": HTMLIonKeyboardControllerElement; + } + interface ElementTagNameMap { + "ion-keyboard-controller": HTMLIonKeyboardControllerElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-keyboard-controller": JSXElements.IonKeyboardControllerAttributes; + } + } + namespace JSXElements { + export interface IonKeyboardControllerAttributes extends HTMLAttributes { + + } + } +} + + +import { + Label as IonLabel +} from './components/label/label'; + +declare global { + interface HTMLIonLabelElement extends IonLabel, HTMLElement { + } + var HTMLIonLabelElement: { + prototype: HTMLIonLabelElement; + new (): HTMLIonLabelElement; + }; + interface HTMLElementTagNameMap { + "ion-label": HTMLIonLabelElement; + } + interface ElementTagNameMap { + "ion-label": HTMLIonLabelElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-label": JSXElements.IonLabelAttributes; + } + } + namespace JSXElements { + export interface IonLabelAttributes extends HTMLAttributes { + color?: string; + fixed?: boolean; + floating?: boolean; + mode?: 'ios' | 'md'; + stacked?: boolean; + } + } +} + + +import { + ListHeader as IonListHeader +} from './components/list-header/list-header'; + +declare global { + interface HTMLIonListHeaderElement extends IonListHeader, HTMLElement { + } + var HTMLIonListHeaderElement: { + prototype: HTMLIonListHeaderElement; + new (): HTMLIonListHeaderElement; + }; + interface HTMLElementTagNameMap { + "ion-list-header": HTMLIonListHeaderElement; + } + interface ElementTagNameMap { + "ion-list-header": HTMLIonListHeaderElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-list-header": JSXElements.IonListHeaderAttributes; + } + } + namespace JSXElements { + export interface IonListHeaderAttributes extends HTMLAttributes { + color?: string; + mode?: 'ios' | 'md'; + } + } +} + + +import { + List as IonList +} from './components/list/list'; + +declare global { + interface HTMLIonListElement extends IonList, HTMLElement { + } + var HTMLIonListElement: { + prototype: HTMLIonListElement; + new (): HTMLIonListElement; + }; + interface HTMLElementTagNameMap { + "ion-list": HTMLIonListElement; + } + interface ElementTagNameMap { + "ion-list": HTMLIonListElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-list": JSXElements.IonListAttributes; + } + } + namespace JSXElements { + export interface IonListAttributes extends HTMLAttributes { + + } + } +} + + +import { + LoadingController as IonLoadingController +} from './components/loading-controller/loading-controller'; + +declare global { + interface HTMLIonLoadingControllerElement extends IonLoadingController, HTMLElement { + } + var HTMLIonLoadingControllerElement: { + prototype: HTMLIonLoadingControllerElement; + new (): HTMLIonLoadingControllerElement; + }; + interface HTMLElementTagNameMap { + "ion-loading-controller": HTMLIonLoadingControllerElement; + } + interface ElementTagNameMap { + "ion-loading-controller": HTMLIonLoadingControllerElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-loading-controller": JSXElements.IonLoadingControllerAttributes; + } + } + namespace JSXElements { + export interface IonLoadingControllerAttributes extends HTMLAttributes { + + } + } +} + + +import { + Loading as IonLoading +} from './components/loading/loading'; + +declare global { + interface HTMLIonLoadingElement extends IonLoading, HTMLElement { + } + var HTMLIonLoadingElement: { + prototype: HTMLIonLoadingElement; + new (): HTMLIonLoadingElement; + }; + interface HTMLElementTagNameMap { + "ion-loading": HTMLIonLoadingElement; + } + interface ElementTagNameMap { + "ion-loading": HTMLIonLoadingElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-loading": JSXElements.IonLoadingAttributes; + } + } + namespace JSXElements { + export interface IonLoadingAttributes extends HTMLAttributes { + content?: string; + cssClass?: string; + dismissOnPageChange?: boolean; + duration?: number; + enterAnimation?: AnimationBuilder; + leaveAnimation?: AnimationBuilder; + showBackdrop?: boolean; + spinner?: string; + translucent?: boolean; + willAnimate?: boolean; + } + } +} + + +import { + MenuController as IonMenuController +} from './components/menu-controller/menu-controller'; + +declare global { + interface HTMLIonMenuControllerElement extends IonMenuController, HTMLElement { + } + var HTMLIonMenuControllerElement: { + prototype: HTMLIonMenuControllerElement; + new (): HTMLIonMenuControllerElement; + }; + interface HTMLElementTagNameMap { + "ion-menu-controller": HTMLIonMenuControllerElement; + } + interface ElementTagNameMap { + "ion-menu-controller": HTMLIonMenuControllerElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-menu-controller": JSXElements.IonMenuControllerAttributes; + } + } + namespace JSXElements { + export interface IonMenuControllerAttributes extends HTMLAttributes { + + } + } +} + + +import { + Menu as IonMenu +} from './components/menu/menu'; + +declare global { + interface HTMLIonMenuElement extends IonMenu, HTMLElement { + } + var HTMLIonMenuElement: { + prototype: HTMLIonMenuElement; + new (): HTMLIonMenuElement; + }; + interface HTMLElementTagNameMap { + "ion-menu": HTMLIonMenuElement; + } + interface ElementTagNameMap { + "ion-menu": HTMLIonMenuElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-menu": JSXElements.IonMenuAttributes; + } + } + namespace JSXElements { + export interface IonMenuAttributes extends HTMLAttributes { + content?: string; + enabled?: boolean; + maxEdgeStart?: number; + menuId?: string; + persistent?: boolean; + side?: Side; + swipeEnabled?: boolean; + type?: string; + } + } +} + + +import { + ModalController as IonModalController +} from './components/modal-controller/modal-controller'; + +declare global { + interface HTMLIonModalControllerElement extends IonModalController, HTMLElement { + } + var HTMLIonModalControllerElement: { + prototype: HTMLIonModalControllerElement; + new (): HTMLIonModalControllerElement; + }; + interface HTMLElementTagNameMap { + "ion-modal-controller": HTMLIonModalControllerElement; + } + interface ElementTagNameMap { + "ion-modal-controller": HTMLIonModalControllerElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-modal-controller": JSXElements.IonModalControllerAttributes; + } + } + namespace JSXElements { + export interface IonModalControllerAttributes extends HTMLAttributes { + + } + } +} + + +import { + Modal as IonModal +} from './components/modal/modal'; + +declare global { + interface HTMLIonModalElement extends IonModal, HTMLElement { + } + var HTMLIonModalElement: { + prototype: HTMLIonModalElement; + new (): HTMLIonModalElement; + }; + interface HTMLElementTagNameMap { + "ion-modal": HTMLIonModalElement; + } + interface ElementTagNameMap { + "ion-modal": HTMLIonModalElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-modal": JSXElements.IonModalAttributes; + } + } + namespace JSXElements { + export interface IonModalAttributes extends HTMLAttributes { + color?: string; + component?: any; + cssClass?: string; + data?: any; + delegate?: FrameworkDelegate; + enableBackdropDismiss?: boolean; + enterAnimation?: AnimationBuilder; + leaveAnimation?: AnimationBuilder; + modalId?: number; + mode?: string; + showBackdrop?: boolean; + willAnimate?: boolean; + } + } +} + + +import { + Nav as IonNav +} from './components/nav/nav'; + +declare global { + interface HTMLIonNavElement extends IonNav, HTMLElement { + } + var HTMLIonNavElement: { + prototype: HTMLIonNavElement; + new (): HTMLIonNavElement; + }; + interface HTMLElementTagNameMap { + "ion-nav": HTMLIonNavElement; + } + interface ElementTagNameMap { + "ion-nav": HTMLIonNavElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-nav": JSXElements.IonNavAttributes; + } + } + namespace JSXElements { + export interface IonNavAttributes extends HTMLAttributes { + delegate?: FrameworkDelegate; + mode?: string; + root?: any; + } + } +} + + +import { + Navbar as IonNavbar +} from './components/navbar/navbar'; + +declare global { + interface HTMLIonNavbarElement extends IonNavbar, HTMLElement { + } + var HTMLIonNavbarElement: { + prototype: HTMLIonNavbarElement; + new (): HTMLIonNavbarElement; + }; + 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 { + backButtonIcon?: string; + backButtonText?: string; + hidden?: boolean; + hideBackButton?: boolean; + } + } +} + + +import { + Note as IonNote +} from './components/note/note'; + +declare global { + interface HTMLIonNoteElement extends IonNote, HTMLElement { + } + var HTMLIonNoteElement: { + prototype: HTMLIonNoteElement; + new (): HTMLIonNoteElement; + }; + interface HTMLElementTagNameMap { + "ion-note": HTMLIonNoteElement; + } + interface ElementTagNameMap { + "ion-note": HTMLIonNoteElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-note": JSXElements.IonNoteAttributes; + } + } + namespace JSXElements { + export interface IonNoteAttributes extends HTMLAttributes { + color?: string; + mode?: 'ios' | 'md'; + } + } +} + + +import { + Page as IonPage +} from './components/page/page'; + +declare global { + interface HTMLIonPageElement extends IonPage, HTMLElement { + } + var HTMLIonPageElement: { + prototype: HTMLIonPageElement; + new (): HTMLIonPageElement; + }; + interface HTMLElementTagNameMap { + "ion-page": HTMLIonPageElement; + } + interface ElementTagNameMap { + "ion-page": HTMLIonPageElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-page": JSXElements.IonPageAttributes; + } + } + namespace JSXElements { + export interface IonPageAttributes extends HTMLAttributes { + + } + } +} + + +import { + PickerColumnCmp as IonPickerColumn +} from './components/picker-column/picker-column'; + +declare global { + interface HTMLIonPickerColumnElement extends IonPickerColumn, HTMLElement { + } + var HTMLIonPickerColumnElement: { + prototype: HTMLIonPickerColumnElement; + new (): HTMLIonPickerColumnElement; + }; + interface HTMLElementTagNameMap { + "ion-picker-column": HTMLIonPickerColumnElement; + } + interface ElementTagNameMap { + "ion-picker-column": HTMLIonPickerColumnElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-picker-column": JSXElements.IonPickerColumnAttributes; + } + } + namespace JSXElements { + export interface IonPickerColumnAttributes extends HTMLAttributes { + col?: PickerColumn; + } + } +} + + +import { + PickerController as IonPickerController +} from './components/picker-controller/picker-controller'; + +declare global { + interface HTMLIonPickerControllerElement extends IonPickerController, HTMLElement { + } + var HTMLIonPickerControllerElement: { + prototype: HTMLIonPickerControllerElement; + new (): HTMLIonPickerControllerElement; + }; + interface HTMLElementTagNameMap { + "ion-picker-controller": HTMLIonPickerControllerElement; + } + interface ElementTagNameMap { + "ion-picker-controller": HTMLIonPickerControllerElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-picker-controller": JSXElements.IonPickerControllerAttributes; + } + } + namespace JSXElements { + export interface IonPickerControllerAttributes extends HTMLAttributes { + + } + } +} + + +import { + Picker as IonPicker +} from './components/picker/picker'; + +declare global { + interface HTMLIonPickerElement extends IonPicker, HTMLElement { + } + var HTMLIonPickerElement: { + prototype: HTMLIonPickerElement; + new (): HTMLIonPickerElement; + }; + interface HTMLElementTagNameMap { + "ion-picker": HTMLIonPickerElement; + } + interface ElementTagNameMap { + "ion-picker": HTMLIonPickerElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-picker": JSXElements.IonPickerAttributes; + } + } + namespace JSXElements { + export interface IonPickerAttributes extends HTMLAttributes { + buttons?: PickerButton[]; + columns?: PickerColumn[]; + content?: string; + cssClass?: string; + dismissOnPageChange?: boolean; + duration?: number; + enableBackdropDismiss?: boolean; + enterAnimation?: AnimationBuilder; + leaveAnimation?: AnimationBuilder; + pickerId?: string; + showBackdrop?: boolean; + willAnimate?: boolean; + } + } +} + + +import { + PopoverController as IonPopoverController +} from './components/popover-controller/popover-controller'; + +declare global { + interface HTMLIonPopoverControllerElement extends IonPopoverController, HTMLElement { + } + var HTMLIonPopoverControllerElement: { + prototype: HTMLIonPopoverControllerElement; + new (): HTMLIonPopoverControllerElement; + }; + interface HTMLElementTagNameMap { + "ion-popover-controller": HTMLIonPopoverControllerElement; + } + interface ElementTagNameMap { + "ion-popover-controller": HTMLIonPopoverControllerElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-popover-controller": JSXElements.IonPopoverControllerAttributes; + } + } + namespace JSXElements { + export interface IonPopoverControllerAttributes extends HTMLAttributes { + + } + } +} + + +import { + Popover as IonPopover +} from './components/popover/popover'; + +declare global { + interface HTMLIonPopoverElement extends IonPopover, HTMLElement { + } + var HTMLIonPopoverElement: { + prototype: HTMLIonPopoverElement; + new (): HTMLIonPopoverElement; + }; + interface HTMLElementTagNameMap { + "ion-popover": HTMLIonPopoverElement; + } + interface ElementTagNameMap { + "ion-popover": HTMLIonPopoverElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-popover": JSXElements.IonPopoverAttributes; + } + } + namespace JSXElements { + export interface IonPopoverAttributes extends HTMLAttributes { + color?: string; + component?: string; + cssClass?: string; + data?: any; + delegate?: FrameworkDelegate; + enableBackdropDismiss?: boolean; + enterAnimation?: AnimationBuilder; + ev?: Event; + leaveAnimation?: AnimationBuilder; + mode?: string; + popoverId?: string; + showBackdrop?: boolean; + translucent?: boolean; + willAnimate?: boolean; + } + } +} + + +import { + RadioGroup as IonRadioGroup +} from './components/radio-group/radio-group'; + +declare global { + interface HTMLIonRadioGroupElement extends IonRadioGroup, HTMLElement { + } + var HTMLIonRadioGroupElement: { + prototype: HTMLIonRadioGroupElement; + new (): HTMLIonRadioGroupElement; + }; + interface HTMLElementTagNameMap { + "ion-radio-group": HTMLIonRadioGroupElement; + } + interface ElementTagNameMap { + "ion-radio-group": HTMLIonRadioGroupElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-radio-group": JSXElements.IonRadioGroupAttributes; + } + } + namespace JSXElements { + export interface IonRadioGroupAttributes extends HTMLAttributes { + allowEmptySelection?: boolean; + disabled?: boolean; + name?: string; + value?: string; + } + } +} + + +import { + Radio as IonRadio +} from './components/radio/radio'; + +declare global { + interface HTMLIonRadioElement extends IonRadio, HTMLElement { + } + var HTMLIonRadioElement: { + prototype: HTMLIonRadioElement; + new (): HTMLIonRadioElement; + }; + interface HTMLElementTagNameMap { + "ion-radio": HTMLIonRadioElement; + } + interface ElementTagNameMap { + "ion-radio": HTMLIonRadioElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-radio": JSXElements.IonRadioAttributes; + } + } + namespace JSXElements { + export interface IonRadioAttributes extends HTMLAttributes { + checked?: boolean; + color?: string; + disabled?: boolean; + mode?: 'ios' | 'md'; + name?: string; + value?: string; + } + } +} + + +import { + RangeKnob as IonRangeKnob +} from './components/range-knob/range-knob'; + +declare global { + interface HTMLIonRangeKnobElement extends IonRangeKnob, HTMLElement { + } + var HTMLIonRangeKnobElement: { + prototype: HTMLIonRangeKnobElement; + new (): HTMLIonRangeKnobElement; + }; + interface HTMLElementTagNameMap { + "ion-range-knob": HTMLIonRangeKnobElement; + } + interface ElementTagNameMap { + "ion-range-knob": HTMLIonRangeKnobElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-range-knob": JSXElements.IonRangeKnobAttributes; + } + } + namespace JSXElements { + export interface IonRangeKnobAttributes extends HTMLAttributes { + disabled?: boolean; + knob?: string; + labelId?: string; + max?: number; + min?: number; + pin?: boolean; + pressed?: boolean; + ratio?: number; + val?: number; + } + } +} + + +import { + Range as IonRange +} from './components/range/range'; + +declare global { + interface HTMLIonRangeElement extends IonRange, HTMLElement { + } + var HTMLIonRangeElement: { + prototype: HTMLIonRangeElement; + new (): HTMLIonRangeElement; + }; + interface HTMLElementTagNameMap { + "ion-range": HTMLIonRangeElement; + } + interface ElementTagNameMap { + "ion-range": HTMLIonRangeElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-range": JSXElements.IonRangeAttributes; + } + } + namespace JSXElements { + export interface IonRangeAttributes extends HTMLAttributes { + color?: string; + debounce?: number; + disabled?: boolean; + dualKnobs?: boolean; + max?: number; + min?: number; + mode?: 'ios' | 'md'; + pin?: boolean; + snaps?: boolean; + step?: number; + value?: any; + } + } +} + + +import { + ReorderGroup as IonReorderGroup +} from './components/reorder-group/reorder-group'; + +declare global { + interface HTMLIonReorderGroupElement extends IonReorderGroup, HTMLElement { + } + var HTMLIonReorderGroupElement: { + prototype: HTMLIonReorderGroupElement; + new (): HTMLIonReorderGroupElement; + }; + interface HTMLElementTagNameMap { + "ion-reorder-group": HTMLIonReorderGroupElement; + } + interface ElementTagNameMap { + "ion-reorder-group": HTMLIonReorderGroupElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-reorder-group": JSXElements.IonReorderGroupAttributes; + } + } + namespace JSXElements { + export interface IonReorderGroupAttributes extends HTMLAttributes { + enabled?: boolean; + } + } +} + + +import { + Reorder as IonReorder +} from './components/reorder/reorder'; + +declare global { + interface HTMLIonReorderElement extends IonReorder, HTMLElement { + } + var HTMLIonReorderElement: { + prototype: HTMLIonReorderElement; + new (): HTMLIonReorderElement; + }; + interface HTMLElementTagNameMap { + "ion-reorder": HTMLIonReorderElement; + } + interface ElementTagNameMap { + "ion-reorder": HTMLIonReorderElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-reorder": JSXElements.IonReorderAttributes; + } + } + namespace JSXElements { + export interface IonReorderAttributes extends HTMLAttributes { + + } + } +} + + +import { + RouteLink as IonRouteLink +} from './components/route-link/route-link'; + +declare global { + interface HTMLIonRouteLinkElement extends IonRouteLink, HTMLElement { + } + var HTMLIonRouteLinkElement: { + prototype: HTMLIonRouteLinkElement; + new (): HTMLIonRouteLinkElement; + }; + interface HTMLElementTagNameMap { + "ion-route-link": HTMLIonRouteLinkElement; + } + interface ElementTagNameMap { + "ion-route-link": HTMLIonRouteLinkElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-route-link": JSXElements.IonRouteLinkAttributes; + } + } + namespace JSXElements { + export interface IonRouteLinkAttributes extends HTMLAttributes { + router?: any; + url?: string; + } + } +} + + +import { + Route as IonRoute +} from './components/route/route'; + +declare global { + interface HTMLIonRouteElement extends IonRoute, HTMLElement { + } + var HTMLIonRouteElement: { + prototype: HTMLIonRouteElement; + new (): HTMLIonRouteElement; + }; + interface HTMLElementTagNameMap { + "ion-route": HTMLIonRouteElement; + } + interface ElementTagNameMap { + "ion-route": HTMLIonRouteElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-route": JSXElements.IonRouteAttributes; + } + } + namespace JSXElements { + export interface IonRouteAttributes extends HTMLAttributes { + component?: string; + path?: string; + props?: any; + } + } +} + + +import { + RouterController as IonRouterController +} from './components/router-controller/router-controller'; + +declare global { + interface HTMLIonRouterControllerElement extends IonRouterController, HTMLElement { + } + var HTMLIonRouterControllerElement: { + prototype: HTMLIonRouterControllerElement; + new (): HTMLIonRouterControllerElement; + }; + interface HTMLElementTagNameMap { + "ion-router-controller": HTMLIonRouterControllerElement; + } + interface ElementTagNameMap { + "ion-router-controller": HTMLIonRouterControllerElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-router-controller": JSXElements.IonRouterControllerAttributes; + } + } + namespace JSXElements { + export interface IonRouterControllerAttributes extends HTMLAttributes { + + } + } +} + + +import { + Row as IonRow +} from './components/row/row'; + +declare global { + interface HTMLIonRowElement extends IonRow, HTMLElement { + } + var HTMLIonRowElement: { + prototype: HTMLIonRowElement; + new (): HTMLIonRowElement; + }; + interface HTMLElementTagNameMap { + "ion-row": HTMLIonRowElement; + } + interface ElementTagNameMap { + "ion-row": HTMLIonRowElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-row": JSXElements.IonRowAttributes; + } + } + namespace JSXElements { + export interface IonRowAttributes extends HTMLAttributes { + + } + } +} + + +import { + Scroll as IonScroll +} from './components/scroll/scroll'; + +declare global { + interface HTMLIonScrollElement extends IonScroll, HTMLElement { + } + var HTMLIonScrollElement: { + prototype: HTMLIonScrollElement; + new (): HTMLIonScrollElement; + }; + interface HTMLElementTagNameMap { + "ion-scroll": HTMLIonScrollElement; + } + interface ElementTagNameMap { + "ion-scroll": HTMLIonScrollElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-scroll": JSXElements.IonScrollAttributes; + } + } + namespace JSXElements { + export interface IonScrollAttributes extends HTMLAttributes { + enabled?: boolean; + jsScroll?: boolean; + onionScroll?: ScrollCallback; + onionScrollEnd?: ScrollCallback; + onionScrollStart?: ScrollCallback; + } + } +} + + +import { + Searchbar as IonSearchbar +} from './components/searchbar/searchbar'; + +declare global { + interface HTMLIonSearchbarElement extends IonSearchbar, HTMLElement { + } + var HTMLIonSearchbarElement: { + prototype: HTMLIonSearchbarElement; + new (): HTMLIonSearchbarElement; + }; + interface HTMLElementTagNameMap { + "ion-searchbar": HTMLIonSearchbarElement; + } + interface ElementTagNameMap { + "ion-searchbar": HTMLIonSearchbarElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-searchbar": JSXElements.IonSearchbarAttributes; + } + } + namespace JSXElements { + export interface IonSearchbarAttributes extends HTMLAttributes { + animated?: boolean; + autocomplete?: string; + autocorrect?: string; + cancelButtonText?: string; + color?: string; + debounce?: number; + mode?: 'ios' | 'md'; + placeholder?: string; + showCancelButton?: boolean; + spellcheck?: boolean; + type?: string; + value?: string; + } + } +} + + +import { + SegmentButton as IonSegmentButton +} from './components/segment-button/segment-button'; + +declare global { + interface HTMLIonSegmentButtonElement extends IonSegmentButton, HTMLElement { + } + var HTMLIonSegmentButtonElement: { + prototype: HTMLIonSegmentButtonElement; + new (): HTMLIonSegmentButtonElement; + }; + interface HTMLElementTagNameMap { + "ion-segment-button": HTMLIonSegmentButtonElement; + } + interface ElementTagNameMap { + "ion-segment-button": HTMLIonSegmentButtonElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-segment-button": JSXElements.IonSegmentButtonAttributes; + } + } + namespace JSXElements { + export interface IonSegmentButtonAttributes extends HTMLAttributes { + checked?: boolean; + color?: string; + disabled?: boolean; + mode?: 'ios' | 'md'; + value?: string; + } + } +} + + +import { + Segment as IonSegment +} from './components/segment/segment'; + +declare global { + interface HTMLIonSegmentElement extends IonSegment, HTMLElement { + } + var HTMLIonSegmentElement: { + prototype: HTMLIonSegmentElement; + new (): HTMLIonSegmentElement; + }; + interface HTMLElementTagNameMap { + "ion-segment": HTMLIonSegmentElement; + } + interface ElementTagNameMap { + "ion-segment": HTMLIonSegmentElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-segment": JSXElements.IonSegmentAttributes; + } + } + namespace JSXElements { + export interface IonSegmentAttributes extends HTMLAttributes { + color?: string; + disabled?: boolean; + mode?: 'ios' | 'md'; + value?: string; + } + } +} + + +import { + SelectOption as IonSelectOption +} from './components/select-option/select-option'; + +declare global { + interface HTMLIonSelectOptionElement extends IonSelectOption, HTMLElement { + } + var HTMLIonSelectOptionElement: { + prototype: HTMLIonSelectOptionElement; + new (): HTMLIonSelectOptionElement; + }; + interface HTMLElementTagNameMap { + "ion-select-option": HTMLIonSelectOptionElement; + } + interface ElementTagNameMap { + "ion-select-option": HTMLIonSelectOptionElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-select-option": JSXElements.IonSelectOptionAttributes; + } + } + namespace JSXElements { + export interface IonSelectOptionAttributes extends HTMLAttributes { + disabled?: boolean; + selected?: boolean; + value?: string; + } + } +} + + +import { + SelectPopover as IonSelectPopover +} from './components/select-popover/select-popover'; + +declare global { + interface HTMLIonSelectPopoverElement extends IonSelectPopover, HTMLElement { + } + var HTMLIonSelectPopoverElement: { + prototype: HTMLIonSelectPopoverElement; + new (): HTMLIonSelectPopoverElement; + }; + interface HTMLElementTagNameMap { + "ion-select-popover": HTMLIonSelectPopoverElement; + } + interface ElementTagNameMap { + "ion-select-popover": HTMLIonSelectPopoverElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-select-popover": JSXElements.IonSelectPopoverAttributes; + } + } + namespace JSXElements { + export interface IonSelectPopoverAttributes extends HTMLAttributes { + message?: string; + options?: SelectPopoverOption[]; + subTitle?: string; + title?: string; + } + } +} + + +import { + Select as IonSelect +} from './components/select/select'; + +declare global { + interface HTMLIonSelectElement extends IonSelect, HTMLElement { + } + var HTMLIonSelectElement: { + prototype: HTMLIonSelectElement; + new (): HTMLIonSelectElement; + }; + interface HTMLElementTagNameMap { + "ion-select": HTMLIonSelectElement; + } + interface ElementTagNameMap { + "ion-select": HTMLIonSelectElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-select": JSXElements.IonSelectAttributes; + } + } + namespace JSXElements { + export interface IonSelectAttributes extends HTMLAttributes { + cancelText?: string; + disabled?: boolean; + interface?: string; + interfaceOptions?: any; + multiple?: boolean; + name?: string; + okText?: string; + placeholder?: string; + selectedText?: string; + value?: string | string[]; + } + } +} + + +import { + SkeletonText as IonSkeletonText +} from './components/skeleton-text/skeleton-text'; + +declare global { + interface HTMLIonSkeletonTextElement extends IonSkeletonText, HTMLElement { + } + var HTMLIonSkeletonTextElement: { + prototype: HTMLIonSkeletonTextElement; + new (): HTMLIonSkeletonTextElement; + }; + interface HTMLElementTagNameMap { + "ion-skeleton-text": HTMLIonSkeletonTextElement; + } + interface ElementTagNameMap { + "ion-skeleton-text": HTMLIonSkeletonTextElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-skeleton-text": JSXElements.IonSkeletonTextAttributes; + } + } + namespace JSXElements { + export interface IonSkeletonTextAttributes extends HTMLAttributes { + width?: string; + } + } +} + + +import { + Slide as IonSlide +} from './components/slide/slide'; + +declare global { + interface HTMLIonSlideElement extends IonSlide, HTMLElement { + } + var HTMLIonSlideElement: { + prototype: HTMLIonSlideElement; + new (): HTMLIonSlideElement; + }; + interface HTMLElementTagNameMap { + "ion-slide": HTMLIonSlideElement; + } + interface ElementTagNameMap { + "ion-slide": HTMLIonSlideElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-slide": JSXElements.IonSlideAttributes; + } + } + namespace JSXElements { + export interface IonSlideAttributes extends HTMLAttributes { + + } + } +} + + +import { + Slides as IonSlides +} from './components/slides/slides'; + +declare global { + interface HTMLIonSlidesElement extends IonSlides, HTMLElement { + } + var HTMLIonSlidesElement: { + prototype: HTMLIonSlidesElement; + new (): HTMLIonSlidesElement; + }; + interface HTMLElementTagNameMap { + "ion-slides": HTMLIonSlidesElement; + } + interface ElementTagNameMap { + "ion-slides": HTMLIonSlidesElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-slides": JSXElements.IonSlidesAttributes; + } + } + namespace JSXElements { + export interface IonSlidesAttributes extends HTMLAttributes { + options?: any; + pager?: boolean; + } + } +} + + +import { + Spinner as IonSpinner +} from './components/spinner/spinner'; + +declare global { + interface HTMLIonSpinnerElement extends IonSpinner, HTMLElement { + } + var HTMLIonSpinnerElement: { + prototype: HTMLIonSpinnerElement; + new (): HTMLIonSpinnerElement; + }; + interface HTMLElementTagNameMap { + "ion-spinner": HTMLIonSpinnerElement; + } + interface ElementTagNameMap { + "ion-spinner": HTMLIonSpinnerElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-spinner": JSXElements.IonSpinnerAttributes; + } + } + namespace JSXElements { + export interface IonSpinnerAttributes extends HTMLAttributes { + color?: string; + duration?: number; + mode?: 'ios' | 'md'; + name?: string; + paused?: boolean; + } + } +} + + +import { + SplitPane as IonSplitPane +} from './components/split-pane/split-pane'; + +declare global { + interface HTMLIonSplitPaneElement extends IonSplitPane, HTMLElement { + } + var HTMLIonSplitPaneElement: { + prototype: HTMLIonSplitPaneElement; + new (): HTMLIonSplitPaneElement; + }; + interface HTMLElementTagNameMap { + "ion-split-pane": HTMLIonSplitPaneElement; + } + interface ElementTagNameMap { + "ion-split-pane": HTMLIonSplitPaneElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-split-pane": JSXElements.IonSplitPaneAttributes; + } + } + namespace JSXElements { + export interface IonSplitPaneAttributes extends HTMLAttributes { + enabled?: boolean; + when?: string | boolean; + } + } +} + + +import { + TabButton as IonTabButton +} from './components/tab-button/tab-button'; + +declare global { + interface HTMLIonTabButtonElement extends IonTabButton, HTMLElement { + } + var HTMLIonTabButtonElement: { + prototype: HTMLIonTabButtonElement; + new (): HTMLIonTabButtonElement; + }; + interface HTMLElementTagNameMap { + "ion-tab-button": HTMLIonTabButtonElement; + } + interface ElementTagNameMap { + "ion-tab-button": HTMLIonTabButtonElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-tab-button": JSXElements.IonTabButtonAttributes; + } + } + namespace JSXElements { + export interface IonTabButtonAttributes extends HTMLAttributes { + selected?: boolean; + tab?: HTMLIonTabElement; + } + } +} + + +import { + Tab as IonTab +} from './components/tab/tab'; + +declare global { + interface HTMLIonTabElement extends IonTab, HTMLElement { + } + var HTMLIonTabElement: { + prototype: HTMLIonTabElement; + new (): HTMLIonTabElement; + }; + interface HTMLElementTagNameMap { + "ion-tab": HTMLIonTabElement; + } + interface ElementTagNameMap { + "ion-tab": HTMLIonTabElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-tab": JSXElements.IonTabAttributes; + } + } + namespace JSXElements { + export interface IonTabAttributes extends HTMLAttributes { + badge?: string; + badgeStyle?: string; + btnId?: string; + enabled?: boolean; + icon?: string; + path?: string; + selected?: boolean; + show?: boolean; + tabsHideOnSubPages?: boolean; + title?: string; + } + } +} + + +import { + Tabbar as IonTabbar +} from './components/tabbar/tabbar'; + +declare global { + interface HTMLIonTabbarElement extends IonTabbar, HTMLElement { + } + var HTMLIonTabbarElement: { + prototype: HTMLIonTabbarElement; + new (): HTMLIonTabbarElement; + }; + interface HTMLElementTagNameMap { + "ion-tabbar": HTMLIonTabbarElement; + } + interface ElementTagNameMap { + "ion-tabbar": HTMLIonTabbarElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-tabbar": JSXElements.IonTabbarAttributes; + } + } + namespace JSXElements { + export interface IonTabbarAttributes extends HTMLAttributes { + highlight?: boolean; + layout?: string; + placement?: string; + scrollable?: Boolean; + selectedTab?: HTMLIonTabElement; + tabs?: HTMLIonTabElement[]; + translucent?: boolean; + } + } +} + + +import { + Tabs as IonTabs +} from './components/tabs/tabs'; + +declare global { + interface HTMLIonTabsElement extends IonTabs, HTMLElement { + } + var HTMLIonTabsElement: { + prototype: HTMLIonTabsElement; + new (): HTMLIonTabsElement; + }; + interface HTMLElementTagNameMap { + "ion-tabs": HTMLIonTabsElement; + } + interface ElementTagNameMap { + "ion-tabs": HTMLIonTabsElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-tabs": JSXElements.IonTabsAttributes; + } + } + namespace JSXElements { + export interface IonTabsAttributes extends HTMLAttributes { + name?: string; + scrollable?: boolean; + tabbarHidden?: boolean; + tabbarHighlight?: boolean; + tabbarLayout?: string; + tabbarPlacement?: string; + translucent?: boolean; + } + } +} + + +import { + Textarea as IonTextarea +} from './components/textarea/textarea'; + +declare global { + interface HTMLIonTextareaElement extends IonTextarea, HTMLElement { + } + var HTMLIonTextareaElement: { + prototype: HTMLIonTextareaElement; + new (): HTMLIonTextareaElement; + }; + interface HTMLElementTagNameMap { + "ion-textarea": HTMLIonTextareaElement; + } + interface ElementTagNameMap { + "ion-textarea": HTMLIonTextareaElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-textarea": JSXElements.IonTextareaAttributes; + } + } + namespace JSXElements { + export interface IonTextareaAttributes extends HTMLAttributes { + autocapitalize?: string; + autocomplete?: string; + autofocus?: boolean; + clearOnEdit?: boolean; + cols?: number; + debounce?: number; + disabled?: boolean; + maxlength?: number; + minlength?: number; + name?: string; + placeholder?: string; + readonly?: boolean; + required?: boolean; + rows?: number; + spellcheck?: boolean; + value?: string; + wrap?: string; + } + } +} + + +import { + Thumbnail as IonThumbnail +} from './components/thumbnail/thumbnail'; + +declare global { + interface HTMLIonThumbnailElement extends IonThumbnail, HTMLElement { + } + var HTMLIonThumbnailElement: { + prototype: HTMLIonThumbnailElement; + new (): HTMLIonThumbnailElement; + }; + interface HTMLElementTagNameMap { + "ion-thumbnail": HTMLIonThumbnailElement; + } + interface ElementTagNameMap { + "ion-thumbnail": HTMLIonThumbnailElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-thumbnail": JSXElements.IonThumbnailAttributes; + } + } + namespace JSXElements { + export interface IonThumbnailAttributes extends HTMLAttributes { + + } + } +} + + +import { + ToolbarTitle as IonTitle +} from './components/title/title'; + +declare global { + interface HTMLIonTitleElement extends IonTitle, HTMLElement { + } + var HTMLIonTitleElement: { + prototype: HTMLIonTitleElement; + new (): HTMLIonTitleElement; + }; + interface HTMLElementTagNameMap { + "ion-title": HTMLIonTitleElement; + } + interface ElementTagNameMap { + "ion-title": HTMLIonTitleElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-title": JSXElements.IonTitleAttributes; + } + } + namespace JSXElements { + export interface IonTitleAttributes extends HTMLAttributes { + + } + } +} + + +import { + ToastController as IonToastController +} from './components/toast-controller/toast-controller'; + +declare global { + interface HTMLIonToastControllerElement extends IonToastController, HTMLElement { + } + var HTMLIonToastControllerElement: { + prototype: HTMLIonToastControllerElement; + new (): HTMLIonToastControllerElement; + }; + interface HTMLElementTagNameMap { + "ion-toast-controller": HTMLIonToastControllerElement; + } + interface ElementTagNameMap { + "ion-toast-controller": HTMLIonToastControllerElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-toast-controller": JSXElements.IonToastControllerAttributes; + } + } + namespace JSXElements { + export interface IonToastControllerAttributes extends HTMLAttributes { + + } + } +} + + +import { + Toast as IonToast +} from './components/toast/toast'; + +declare global { + interface HTMLIonToastElement extends IonToast, HTMLElement { + } + var HTMLIonToastElement: { + prototype: HTMLIonToastElement; + new (): HTMLIonToastElement; + }; + interface HTMLElementTagNameMap { + "ion-toast": HTMLIonToastElement; + } + interface ElementTagNameMap { + "ion-toast": HTMLIonToastElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-toast": JSXElements.IonToastAttributes; + } + } + namespace JSXElements { + export interface IonToastAttributes extends HTMLAttributes { + closeButtonText?: string; + cssClass?: string; + dismissOnPageChange?: boolean; + duration?: number; + enterAnimation?: AnimationBuilder; + leaveAnimation?: AnimationBuilder; + message?: string; + position?: string; + showCloseButton?: boolean; + toastId?: string; + translucent?: boolean; + willAnimate?: boolean; + } + } +} + + +import { + Toggle as IonToggle +} from './components/toggle/toggle'; + +declare global { + interface HTMLIonToggleElement extends IonToggle, HTMLElement { + } + var HTMLIonToggleElement: { + prototype: HTMLIonToggleElement; + new (): HTMLIonToggleElement; + }; + interface HTMLElementTagNameMap { + "ion-toggle": HTMLIonToggleElement; + } + interface ElementTagNameMap { + "ion-toggle": HTMLIonToggleElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-toggle": JSXElements.IonToggleAttributes; + } + } + namespace JSXElements { + export interface IonToggleAttributes extends HTMLAttributes { + checked?: boolean; + color?: string; + disabled?: boolean; + mode?: 'ios' | 'md'; + name?: string; + value?: string; + } + } +} + + +import { + Toolbar as IonToolbar +} from './components/toolbar/toolbar'; + +declare global { + interface HTMLIonToolbarElement extends IonToolbar, HTMLElement { + } + var HTMLIonToolbarElement: { + prototype: HTMLIonToolbarElement; + new (): HTMLIonToolbarElement; + }; + interface HTMLElementTagNameMap { + "ion-toolbar": HTMLIonToolbarElement; + } + interface ElementTagNameMap { + "ion-toolbar": HTMLIonToolbarElement; + } + namespace JSX { + interface IntrinsicElements { + "ion-toolbar": JSXElements.IonToolbarAttributes; + } + } + namespace JSXElements { + export interface IonToolbarAttributes extends HTMLAttributes { + color?: string; + mode?: 'ios' | 'md'; + translucent?: boolean; + } + } +} + diff --git a/packages/core/src/components/item-group/item-group.ios.scss b/packages/core/src/components/item-group/item-group.ios.scss new file mode 100644 index 0000000000..913a819573 --- /dev/null +++ b/packages/core/src/components/item-group/item-group.ios.scss @@ -0,0 +1,15 @@ +@import "./item-group"; +@import "./item-group.ios.vars"; + + +// iOS Item Group +// -------------------------------------------------- + +.item-group-ios ion-item:first-child .item-inner { + border-top-width: 0; +} + +.item-group-ios ion-item:last-child .item-inner, +.item-group-ios .item-wrapper:last-child .item .item-inner { + border: 0; +} diff --git a/packages/core/src/components/item-group/item-group.ios.vars.scss b/packages/core/src/components/item-group/item-group.ios.vars.scss new file mode 100644 index 0000000000..4658799381 --- /dev/null +++ b/packages/core/src/components/item-group/item-group.ios.vars.scss @@ -0,0 +1,4 @@ +@import "../../themes/ionic.globals.ios"; + +// iOS Item Group +// -------------------------------------------------- diff --git a/packages/core/src/components/item-group/item-group.md.scss b/packages/core/src/components/item-group/item-group.md.scss new file mode 100644 index 0000000000..87e8a27bc5 --- /dev/null +++ b/packages/core/src/components/item-group/item-group.md.scss @@ -0,0 +1,15 @@ +@import "./item-group"; +@import "./item-group.md.vars"; + + +// Material Design Item Group +// -------------------------------------------------- + +.item-group-md ion-item:first-child .item-inner { + border-top-width: 0; +} + +.item-group-md ion-item:last-child .item-inner, +.item-group-md .item-wrapper:last-child .item .item-inner { + border: 0; +} diff --git a/packages/core/src/components/item-group/item-group.md.vars.scss b/packages/core/src/components/item-group/item-group.md.vars.scss new file mode 100644 index 0000000000..dd1b400f56 --- /dev/null +++ b/packages/core/src/components/item-group/item-group.md.vars.scss @@ -0,0 +1,4 @@ +@import "../../themes/ionic.globals.md"; + +// Material Design Item Group +// -------------------------------------------------- diff --git a/packages/core/src/components/item-group/item-group.scss b/packages/core/src/components/item-group/item-group.scss new file mode 100644 index 0000000000..758a253b74 --- /dev/null +++ b/packages/core/src/components/item-group/item-group.scss @@ -0,0 +1,9 @@ +@import "./item-group.vars"; + + +// Item Group +// -------------------------------------------------- + +ion-item-group { + display: block; +} \ No newline at end of file diff --git a/packages/core/src/components/item-group/item-group.tsx b/packages/core/src/components/item-group/item-group.tsx new file mode 100644 index 0000000000..6aecba33aa --- /dev/null +++ b/packages/core/src/components/item-group/item-group.tsx @@ -0,0 +1,18 @@ +import { Component } from '@stencil/core'; + + +@Component({ + tag: 'ion-item-group', + styleUrls: { + ios: 'item-group.ios.scss', + md: 'item-group.md.scss' + }, + host: { + theme: 'item-group' + } +}) +export class ItemGroup { + render() { + return ; + } +} diff --git a/packages/core/src/components/item-group/item-group.vars.scss b/packages/core/src/components/item-group/item-group.vars.scss new file mode 100644 index 0000000000..1c7bd2a4a9 --- /dev/null +++ b/packages/core/src/components/item-group/item-group.vars.scss @@ -0,0 +1,5 @@ +@import "../../themes/ionic.globals"; + + +// Item Group +// -------------------------------------------------- diff --git a/packages/core/src/components/item/item.ios.scss b/packages/core/src/components/item/item.ios.scss index a1692e94ac..8f06b10d17 100644 --- a/packages/core/src/components/item/item.ios.scss +++ b/packages/core/src/components/item/item.ios.scss @@ -167,19 +167,6 @@ } -// iOS Item Group -// -------------------------------------------------- - -ion-item-group .item-ios:first-child .item-inner { - border-top-width: 0; -} - -ion-item-group .item-ios:last-child .item-inner, -ion-item-group .item-wrapper:last-child .item-ios .item-inner { - border: 0; -} - - // Generate iOS Item and Item Divider Colors // -------------------------------------------------- diff --git a/packages/core/src/components/item/item.md.scss b/packages/core/src/components/item/item.md.scss index dd90c543d1..33ea679965 100644 --- a/packages/core/src/components/item/item.md.scss +++ b/packages/core/src/components/item/item.md.scss @@ -153,19 +153,6 @@ } -// Material Design Item Group -// -------------------------------------------------- - -ion-item-group .item-md:first-child .item-inner { - border-top-width: 0; -} - -ion-item-group .item-md:last-child .item-inner, -ion-item-group .item-md .item-wrapper:last-child .item-inner { - border: 0; -} - - // Generate Material Design Item and Item Divider Colors // --------------------------------------------------