@ionic/angular

@ionic/angular

Version 8.5.5
Published 11 days ago
3.28 MB
4 dependencies
MIT license

Install

npm i @ionic/angular

yarn add @ionic/angular

pnpm add @ionic/angular

Overview

Angular specific wrappers for @ionic/core

Index

Variables

variable ION_MAX_VALIDATOR

const ION_MAX_VALIDATOR: Provider;

Provider which adds MaxValidator to the NG_VALIDATORS multi-provider list.

variable ION_MIN_VALIDATOR

const ION_MIN_VALIDATOR: Provider;

Provider which adds MinValidator to the NG_VALIDATORS multi-provider list.

Classes

class ActionSheetController

class ActionSheetController extends OverlayBaseController<
    ActionSheetOptions,
    HTMLIonActionSheetElement
> {}

constructor

constructor();

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<ActionSheetController, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<ActionSheetController>;

class AlertController

class AlertController extends OverlayBaseController<
    AlertOptions,
    HTMLIonAlertElement
> {}

constructor

constructor();

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<AlertController, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<AlertController>;

class AnimationController

class AnimationController {}

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<AnimationController, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<AnimationController>;

method create

create: (animationId?: string) => Animation;

Create a new animation

method easingTime

easingTime: (
    p0: number[],
    p1: number[],
    p2: number[],
    p3: number[],
    progression: number
) => number[];

EXPERIMENTAL
Given a progression and a cubic bezier function, this utility returns the time value(s) at which the cubic bezier reaches the given time progression.
If the cubic bezier never reaches the progression the result will be an empty array.
This is most useful for switching between easing curves when doing a gesture animation (i.e. going from linear easing during a drag, to another easing when progressEnd is called)

class BooleanValueAccessor

class BooleanValueAccessorDirective extends ValueAccessor {}

constructor

constructor(injector: Injector, el: ElementRef);

property ɵdir

static ɵdir: i0.ɵɵDirectiveDeclaration<
    BooleanValueAccessorDirective,
    'ion-checkbox,ion-toggle',
    never,
    {},
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<BooleanValueAccessorDirective, never>;

method writeValue

writeValue: (value: boolean) => void;

class GestureController

class GestureController {}

constructor

constructor(zone: NgZone);

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<GestureController, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<GestureController>;

method create

create: (opts: GestureConfig, runInsideAngularZone?: boolean) => Gesture;

Create a new gesture

class IonAccordion

class IonAccordion {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonAccordionElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonAccordion,
    'ion-accordion',
    never,
    {
        disabled: { alias: 'disabled'; required: false };
        mode: { alias: 'mode'; required: false };
        readonly: { alias: 'readonly'; required: false };
        toggleIcon: { alias: 'toggleIcon'; required: false };
        toggleIconSlot: { alias: 'toggleIconSlot'; required: false };
        value: { alias: 'value'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonAccordion, never>;

property z

protected z: NgZone;

class IonAccordionGroup

class IonAccordionGroup {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonAccordionGroupElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonAccordionGroup,
    'ion-accordion-group',
    never,
    {
        animated: { alias: 'animated'; required: false };
        disabled: { alias: 'disabled'; required: false };
        expand: { alias: 'expand'; required: false };
        mode: { alias: 'mode'; required: false };
        multiple: { alias: 'multiple'; required: false };
        readonly: { alias: 'readonly'; required: false };
        value: { alias: 'value'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonAccordionGroup, never>;

property z

protected z: NgZone;

class IonActionSheet

class IonActionSheet {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonActionSheetElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonActionSheet,
    'ion-action-sheet',
    never,
    {
        animated: { alias: 'animated'; required: false };
        backdropDismiss: { alias: 'backdropDismiss'; required: false };
        buttons: { alias: 'buttons'; required: false };
        cssClass: { alias: 'cssClass'; required: false };
        enterAnimation: { alias: 'enterAnimation'; required: false };
        header: { alias: 'header'; required: false };
        htmlAttributes: { alias: 'htmlAttributes'; required: false };
        isOpen: { alias: 'isOpen'; required: false };
        keyboardClose: { alias: 'keyboardClose'; required: false };
        leaveAnimation: { alias: 'leaveAnimation'; required: false };
        mode: { alias: 'mode'; required: false };
        subHeader: { alias: 'subHeader'; required: false };
        translucent: { alias: 'translucent'; required: false };
        trigger: { alias: 'trigger'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonActionSheet, never>;

property z

protected z: NgZone;

class IonAlert

class IonAlert {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonAlertElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonAlert,
    'ion-alert',
    never,
    {
        animated: { alias: 'animated'; required: false };
        backdropDismiss: { alias: 'backdropDismiss'; required: false };
        buttons: { alias: 'buttons'; required: false };
        cssClass: { alias: 'cssClass'; required: false };
        enterAnimation: { alias: 'enterAnimation'; required: false };
        header: { alias: 'header'; required: false };
        htmlAttributes: { alias: 'htmlAttributes'; required: false };
        inputs: { alias: 'inputs'; required: false };
        isOpen: { alias: 'isOpen'; required: false };
        keyboardClose: { alias: 'keyboardClose'; required: false };
        leaveAnimation: { alias: 'leaveAnimation'; required: false };
        message: { alias: 'message'; required: false };
        mode: { alias: 'mode'; required: false };
        subHeader: { alias: 'subHeader'; required: false };
        translucent: { alias: 'translucent'; required: false };
        trigger: { alias: 'trigger'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonAlert, never>;

property z

protected z: NgZone;

class IonApp

class IonApp {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonAppElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonApp,
    'ion-app',
    never,
    {},
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonApp, never>;

property z

protected z: NgZone;

class IonAvatar

class IonAvatar {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonAvatarElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonAvatar,
    'ion-avatar',
    never,
    {},
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonAvatar, never>;

property z

protected z: NgZone;

class IonBackButton

class IonBackButton extends IonBackButtonBase {}

constructor

constructor(
    routerOutlet: IonRouterOutlet,
    navCtrl: NavController,
    config: Config,
    r: ElementRef,
    z: NgZone,
    c: ChangeDetectorRef
);

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonBackButton,
    'ion-back-button',
    never,
    {},
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<
    IonBackButton,
    [{ optional: true }, null, null, null, null, null]
>;

class IonBackdrop

class IonBackdrop {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonBackdropElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonBackdrop,
    'ion-backdrop',
    never,
    {
        stopPropagation: { alias: 'stopPropagation'; required: false };
        tappable: { alias: 'tappable'; required: false };
        visible: { alias: 'visible'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonBackdrop, never>;

property z

protected z: NgZone;

class IonBadge

class IonBadge {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonBadgeElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonBadge,
    'ion-badge',
    never,
    {
        color: { alias: 'color'; required: false };
        mode: { alias: 'mode'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonBadge, never>;

property z

protected z: NgZone;

class IonBreadcrumb

class IonBreadcrumb {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonBreadcrumbElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonBreadcrumb,
    'ion-breadcrumb',
    never,
    {
        active: { alias: 'active'; required: false };
        color: { alias: 'color'; required: false };
        disabled: { alias: 'disabled'; required: false };
        download: { alias: 'download'; required: false };
        href: { alias: 'href'; required: false };
        mode: { alias: 'mode'; required: false };
        rel: { alias: 'rel'; required: false };
        routerAnimation: { alias: 'routerAnimation'; required: false };
        routerDirection: { alias: 'routerDirection'; required: false };
        separator: { alias: 'separator'; required: false };
        target: { alias: 'target'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonBreadcrumb, never>;

property z

protected z: NgZone;

class IonBreadcrumbs

class IonBreadcrumbs {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonBreadcrumbsElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonBreadcrumbs,
    'ion-breadcrumbs',
    never,
    {
        color: { alias: 'color'; required: false };
        itemsAfterCollapse: { alias: 'itemsAfterCollapse'; required: false };
        itemsBeforeCollapse: { alias: 'itemsBeforeCollapse'; required: false };
        maxItems: { alias: 'maxItems'; required: false };
        mode: { alias: 'mode'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonBreadcrumbs, never>;

property z

protected z: NgZone;

class IonButton

class IonButton {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonButtonElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonButton,
    'ion-button',
    never,
    {
        buttonType: { alias: 'buttonType'; required: false };
        color: { alias: 'color'; required: false };
        disabled: { alias: 'disabled'; required: false };
        download: { alias: 'download'; required: false };
        expand: { alias: 'expand'; required: false };
        fill: { alias: 'fill'; required: false };
        form: { alias: 'form'; required: false };
        href: { alias: 'href'; required: false };
        mode: { alias: 'mode'; required: false };
        rel: { alias: 'rel'; required: false };
        routerAnimation: { alias: 'routerAnimation'; required: false };
        routerDirection: { alias: 'routerDirection'; required: false };
        shape: { alias: 'shape'; required: false };
        size: { alias: 'size'; required: false };
        strong: { alias: 'strong'; required: false };
        target: { alias: 'target'; required: false };
        type: { alias: 'type'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonButton, never>;

property z

protected z: NgZone;

class IonButtons

class IonButtons {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonButtonsElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonButtons,
    'ion-buttons',
    never,
    { collapse: { alias: 'collapse'; required: false } },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonButtons, never>;

property z

protected z: NgZone;

class IonCard

class IonCard {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonCardElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonCard,
    'ion-card',
    never,
    {
        button: { alias: 'button'; required: false };
        color: { alias: 'color'; required: false };
        disabled: { alias: 'disabled'; required: false };
        download: { alias: 'download'; required: false };
        href: { alias: 'href'; required: false };
        mode: { alias: 'mode'; required: false };
        rel: { alias: 'rel'; required: false };
        routerAnimation: { alias: 'routerAnimation'; required: false };
        routerDirection: { alias: 'routerDirection'; required: false };
        target: { alias: 'target'; required: false };
        type: { alias: 'type'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonCard, never>;

property z

protected z: NgZone;

class IonCardContent

class IonCardContent {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonCardContentElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonCardContent,
    'ion-card-content',
    never,
    { mode: { alias: 'mode'; required: false } },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonCardContent, never>;

property z

protected z: NgZone;

class IonCardHeader

class IonCardHeader {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonCardHeaderElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonCardHeader,
    'ion-card-header',
    never,
    {
        color: { alias: 'color'; required: false };
        mode: { alias: 'mode'; required: false };
        translucent: { alias: 'translucent'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonCardHeader, never>;

property z

protected z: NgZone;

class IonCardSubtitle

class IonCardSubtitle {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonCardSubtitleElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonCardSubtitle,
    'ion-card-subtitle',
    never,
    {
        color: { alias: 'color'; required: false };
        mode: { alias: 'mode'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonCardSubtitle, never>;

property z

protected z: NgZone;

class IonCardTitle

class IonCardTitle {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonCardTitleElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonCardTitle,
    'ion-card-title',
    never,
    {
        color: { alias: 'color'; required: false };
        mode: { alias: 'mode'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonCardTitle, never>;

property z

protected z: NgZone;

class IonCheckbox

class IonCheckbox {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonCheckboxElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonCheckbox,
    'ion-checkbox',
    never,
    {
        alignment: { alias: 'alignment'; required: false };
        checked: { alias: 'checked'; required: false };
        color: { alias: 'color'; required: false };
        disabled: { alias: 'disabled'; required: false };
        errorText: { alias: 'errorText'; required: false };
        helperText: { alias: 'helperText'; required: false };
        indeterminate: { alias: 'indeterminate'; required: false };
        justify: { alias: 'justify'; required: false };
        labelPlacement: { alias: 'labelPlacement'; required: false };
        mode: { alias: 'mode'; required: false };
        name: { alias: 'name'; required: false };
        required: { alias: 'required'; required: false };
        value: { alias: 'value'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonCheckbox, never>;

property z

protected z: NgZone;

class IonChip

class IonChip {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonChipElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonChip,
    'ion-chip',
    never,
    {
        color: { alias: 'color'; required: false };
        disabled: { alias: 'disabled'; required: false };
        mode: { alias: 'mode'; required: false };
        outline: { alias: 'outline'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonChip, never>;

property z

protected z: NgZone;

class IonCol

class IonCol {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonColElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonCol,
    'ion-col',
    never,
    {
        offset: { alias: 'offset'; required: false };
        offsetLg: { alias: 'offsetLg'; required: false };
        offsetMd: { alias: 'offsetMd'; required: false };
        offsetSm: { alias: 'offsetSm'; required: false };
        offsetXl: { alias: 'offsetXl'; required: false };
        offsetXs: { alias: 'offsetXs'; required: false };
        pull: { alias: 'pull'; required: false };
        pullLg: { alias: 'pullLg'; required: false };
        pullMd: { alias: 'pullMd'; required: false };
        pullSm: { alias: 'pullSm'; required: false };
        pullXl: { alias: 'pullXl'; required: false };
        pullXs: { alias: 'pullXs'; required: false };
        push: { alias: 'push'; required: false };
        pushLg: { alias: 'pushLg'; required: false };
        pushMd: { alias: 'pushMd'; required: false };
        pushSm: { alias: 'pushSm'; required: false };
        pushXl: { alias: 'pushXl'; required: false };
        pushXs: { alias: 'pushXs'; required: false };
        size: { alias: 'size'; required: false };
        sizeLg: { alias: 'sizeLg'; required: false };
        sizeMd: { alias: 'sizeMd'; required: false };
        sizeSm: { alias: 'sizeSm'; required: false };
        sizeXl: { alias: 'sizeXl'; required: false };
        sizeXs: { alias: 'sizeXs'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonCol, never>;

property z

protected z: NgZone;

class IonContent

class IonContent {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonContentElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonContent,
    'ion-content',
    never,
    {
        color: { alias: 'color'; required: false };
        fixedSlotPlacement: { alias: 'fixedSlotPlacement'; required: false };
        forceOverscroll: { alias: 'forceOverscroll'; required: false };
        fullscreen: { alias: 'fullscreen'; required: false };
        scrollEvents: { alias: 'scrollEvents'; required: false };
        scrollX: { alias: 'scrollX'; required: false };
        scrollY: { alias: 'scrollY'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonContent, never>;

property z

protected z: NgZone;

class IonDatetime

class IonDatetime {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonDatetimeElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonDatetime,
    'ion-datetime',
    never,
    {
        cancelText: { alias: 'cancelText'; required: false };
        clearText: { alias: 'clearText'; required: false };
        color: { alias: 'color'; required: false };
        dayValues: { alias: 'dayValues'; required: false };
        disabled: { alias: 'disabled'; required: false };
        doneText: { alias: 'doneText'; required: false };
        firstDayOfWeek: { alias: 'firstDayOfWeek'; required: false };
        formatOptions: { alias: 'formatOptions'; required: false };
        highlightedDates: { alias: 'highlightedDates'; required: false };
        hourCycle: { alias: 'hourCycle'; required: false };
        hourValues: { alias: 'hourValues'; required: false };
        isDateEnabled: { alias: 'isDateEnabled'; required: false };
        locale: { alias: 'locale'; required: false };
        max: { alias: 'max'; required: false };
        min: { alias: 'min'; required: false };
        minuteValues: { alias: 'minuteValues'; required: false };
        mode: { alias: 'mode'; required: false };
        monthValues: { alias: 'monthValues'; required: false };
        multiple: { alias: 'multiple'; required: false };
        name: { alias: 'name'; required: false };
        preferWheel: { alias: 'preferWheel'; required: false };
        presentation: { alias: 'presentation'; required: false };
        readonly: { alias: 'readonly'; required: false };
        showClearButton: { alias: 'showClearButton'; required: false };
        showDefaultButtons: { alias: 'showDefaultButtons'; required: false };
        showDefaultTimeLabel: { alias: 'showDefaultTimeLabel'; required: false };
        showDefaultTitle: { alias: 'showDefaultTitle'; required: false };
        size: { alias: 'size'; required: false };
        titleSelectedDatesFormatter: {
            alias: 'titleSelectedDatesFormatter';
            required: false;
        };
        value: { alias: 'value'; required: false };
        yearValues: { alias: 'yearValues'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonDatetime, never>;

property z

protected z: NgZone;

class IonDatetimeButton

class IonDatetimeButton {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonDatetimeButtonElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonDatetimeButton,
    'ion-datetime-button',
    never,
    {
        color: { alias: 'color'; required: false };
        datetime: { alias: 'datetime'; required: false };
        disabled: { alias: 'disabled'; required: false };
        mode: { alias: 'mode'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonDatetimeButton, never>;

property z

protected z: NgZone;

class IonFab

class IonFab {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonFabElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonFab,
    'ion-fab',
    never,
    {
        activated: { alias: 'activated'; required: false };
        edge: { alias: 'edge'; required: false };
        horizontal: { alias: 'horizontal'; required: false };
        vertical: { alias: 'vertical'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonFab, never>;

property z

protected z: NgZone;

class IonFabButton

class IonFabButton {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonFabButtonElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonFabButton,
    'ion-fab-button',
    never,
    {
        activated: { alias: 'activated'; required: false };
        closeIcon: { alias: 'closeIcon'; required: false };
        color: { alias: 'color'; required: false };
        disabled: { alias: 'disabled'; required: false };
        download: { alias: 'download'; required: false };
        href: { alias: 'href'; required: false };
        mode: { alias: 'mode'; required: false };
        rel: { alias: 'rel'; required: false };
        routerAnimation: { alias: 'routerAnimation'; required: false };
        routerDirection: { alias: 'routerDirection'; required: false };
        show: { alias: 'show'; required: false };
        size: { alias: 'size'; required: false };
        target: { alias: 'target'; required: false };
        translucent: { alias: 'translucent'; required: false };
        type: { alias: 'type'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonFabButton, never>;

property z

protected z: NgZone;

class IonFabList

class IonFabList {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonFabListElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonFabList,
    'ion-fab-list',
    never,
    {
        activated: { alias: 'activated'; required: false };
        side: { alias: 'side'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonFabList, never>;

property z

protected z: NgZone;

class IonFooter

class IonFooter {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonFooterElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonFooter,
    'ion-footer',
    never,
    {
        collapse: { alias: 'collapse'; required: false };
        mode: { alias: 'mode'; required: false };
        translucent: { alias: 'translucent'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonFooter, never>;

property z

protected z: NgZone;

class IonGrid

class IonGrid {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonGridElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonGrid,
    'ion-grid',
    never,
    { fixed: { alias: 'fixed'; required: false } },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonGrid, never>;

property z

protected z: NgZone;

class IonHeader

class IonHeader {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonHeaderElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonHeader,
    'ion-header',
    never,
    {
        collapse: { alias: 'collapse'; required: false };
        mode: { alias: 'mode'; required: false };
        translucent: { alias: 'translucent'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonHeader, never>;

property z

protected z: NgZone;

class IonicModule

class IonicModule {}

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonicModule, never>;

property ɵinj

static ɵinj: i0.ɵɵInjectorDeclaration<IonicModule>;

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<
    IonicModule,
    [
        typeof i1.IonAccordion,
        typeof i1.IonAccordionGroup,
        typeof i1.IonActionSheet,
        typeof i1.IonAlert,
        typeof i1.IonApp,
        typeof i1.IonAvatar,
        typeof i1.IonBackdrop,
        typeof i1.IonBadge,
        typeof i1.IonBreadcrumb,
        typeof i1.IonBreadcrumbs,
        typeof i1.IonButton,
        typeof i1.IonButtons,
        typeof i1.IonCard,
        typeof i1.IonCardContent,
        typeof i1.IonCardHeader,
        typeof i1.IonCardSubtitle,
        typeof i1.IonCardTitle,
        typeof i1.IonCheckbox,
        typeof i1.IonChip,
        typeof i1.IonCol,
        typeof i1.IonContent,
        typeof i1.IonDatetime,
        typeof i1.IonDatetimeButton,
        typeof i1.IonFab,
        typeof i1.IonFabButton,
        typeof i1.IonFabList,
        typeof i1.IonFooter,
        typeof i1.IonGrid,
        typeof i1.IonHeader,
        typeof i1.IonIcon,
        typeof i1.IonImg,
        typeof i1.IonInfiniteScroll,
        typeof i1.IonInfiniteScrollContent,
        typeof i1.IonInput,
        typeof i1.IonInputPasswordToggle,
        typeof i1.IonItem,
        typeof i1.IonItemDivider,
        typeof i1.IonItemGroup,
        typeof i1.IonItemOption,
        typeof i1.IonItemOptions,
        typeof i1.IonItemSliding,
        typeof i1.IonLabel,
        typeof i1.IonList,
        typeof i1.IonListHeader,
        typeof i1.IonLoading,
        typeof i1.IonMenu,
        typeof i1.IonMenuButton,
        typeof i1.IonMenuToggle,
        typeof i1.IonNavLink,
        typeof i1.IonNote,
        typeof i1.IonPicker,
        typeof i1.IonPickerColumn,
        typeof i1.IonPickerColumnOption,
        typeof i1.IonPickerLegacy,
        typeof i1.IonProgressBar,
        typeof i1.IonRadio,
        typeof i1.IonRadioGroup,
        typeof i1.IonRange,
        typeof i1.IonRefresher,
        typeof i1.IonRefresherContent,
        typeof i1.IonReorder,
        typeof i1.IonReorderGroup,
        typeof i1.IonRippleEffect,
        typeof i1.IonRow,
        typeof i1.IonSearchbar,
        typeof i1.IonSegment,
        typeof i1.IonSegmentButton,
        typeof i1.IonSegmentContent,
        typeof i1.IonSegmentView,
        typeof i1.IonSelect,
        typeof i1.IonSelectModal,
        typeof i1.IonSelectOption,
        typeof i1.IonSkeletonText,
        typeof i1.IonSpinner,
        typeof i1.IonSplitPane,
        typeof i1.IonTab,
        typeof i1.IonTabBar,
        typeof i1.IonTabButton,
        typeof i1.IonText,
        typeof i1.IonTextarea,
        typeof i1.IonThumbnail,
        typeof i1.IonTitle,
        typeof i1.IonToast,
        typeof i1.IonToggle,
        typeof i1.IonToolbar,
        typeof i2.IonModal,
        typeof i3.IonPopover,
        typeof i4.BooleanValueAccessorDirective,
        typeof i5.NumericValueAccessorDirective,
        typeof i6.SelectValueAccessorDirective,
        typeof i7.TextValueAccessorDirective,
        typeof i8.IonTabs,
        typeof i9.IonRouterOutlet,
        typeof i10.IonBackButton,
        typeof i11.IonNav,
        typeof i12.RouterLinkDelegateDirective,
        typeof i12.RouterLinkWithHrefDelegateDirective,
        typeof i13.IonMinValidator,
        typeof i14.IonMaxValidator
    ],
    [any],
    [
        typeof i1.IonAccordion,
        typeof i1.IonAccordionGroup,
        typeof i1.IonActionSheet,
        typeof i1.IonAlert,
        typeof i1.IonApp,
        typeof i1.IonAvatar,
        typeof i1.IonBackdrop,
        typeof i1.IonBadge,
        typeof i1.IonBreadcrumb,
        typeof i1.IonBreadcrumbs,
        typeof i1.IonButton,
        typeof i1.IonButtons,
        typeof i1.IonCard,
        typeof i1.IonCardContent,
        typeof i1.IonCardHeader,
        typeof i1.IonCardSubtitle,
        typeof i1.IonCardTitle,
        typeof i1.IonCheckbox,
        typeof i1.IonChip,
        typeof i1.IonCol,
        typeof i1.IonContent,
        typeof i1.IonDatetime,
        typeof i1.IonDatetimeButton,
        typeof i1.IonFab,
        typeof i1.IonFabButton,
        typeof i1.IonFabList,
        typeof i1.IonFooter,
        typeof i1.IonGrid,
        typeof i1.IonHeader,
        typeof i1.IonIcon,
        typeof i1.IonImg,
        typeof i1.IonInfiniteScroll,
        typeof i1.IonInfiniteScrollContent,
        typeof i1.IonInput,
        typeof i1.IonInputPasswordToggle,
        typeof i1.IonItem,
        typeof i1.IonItemDivider,
        typeof i1.IonItemGroup,
        typeof i1.IonItemOption,
        typeof i1.IonItemOptions,
        typeof i1.IonItemSliding,
        typeof i1.IonLabel,
        typeof i1.IonList,
        typeof i1.IonListHeader,
        typeof i1.IonLoading,
        typeof i1.IonMenu,
        typeof i1.IonMenuButton,
        typeof i1.IonMenuToggle,
        typeof i1.IonNavLink,
        typeof i1.IonNote,
        typeof i1.IonPicker,
        typeof i1.IonPickerColumn,
        typeof i1.IonPickerColumnOption,
        typeof i1.IonPickerLegacy,
        typeof i1.IonProgressBar,
        typeof i1.IonRadio,
        typeof i1.IonRadioGroup,
        typeof i1.IonRange,
        typeof i1.IonRefresher,
        typeof i1.IonRefresherContent,
        typeof i1.IonReorder,
        typeof i1.IonReorderGroup,
        typeof i1.IonRippleEffect,
        typeof i1.IonRow,
        typeof i1.IonSearchbar,
        typeof i1.IonSegment,
        typeof i1.IonSegmentButton,
        typeof i1.IonSegmentContent,
        typeof i1.IonSegmentView,
        typeof i1.IonSelect,
        typeof i1.IonSelectModal,
        typeof i1.IonSelectOption,
        typeof i1.IonSkeletonText,
        typeof i1.IonSpinner,
        typeof i1.IonSplitPane,
        typeof i1.IonTab,
        typeof i1.IonTabBar,
        typeof i1.IonTabButton,
        typeof i1.IonText,
        typeof i1.IonTextarea,
        typeof i1.IonThumbnail,
        typeof i1.IonTitle,
        typeof i1.IonToast,
        typeof i1.IonToggle,
        typeof i1.IonToolbar,
        typeof i2.IonModal,
        typeof i3.IonPopover,
        typeof i4.BooleanValueAccessorDirective,
        typeof i5.NumericValueAccessorDirective,
        typeof i6.SelectValueAccessorDirective,
        typeof i7.TextValueAccessorDirective,
        typeof i8.IonTabs,
        typeof i9.IonRouterOutlet,
        typeof i10.IonBackButton,
        typeof i11.IonNav,
        typeof i12.RouterLinkDelegateDirective,
        typeof i12.RouterLinkWithHrefDelegateDirective,
        typeof i13.IonMinValidator,
        typeof i14.IonMaxValidator
    ]
>;

method forRoot

static forRoot: (
    config?: IonicConfig & OptInAngularFeatures
) => ModuleWithProviders<IonicModule>;

class IonIcon

class IonIcon {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonIconElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonIcon,
    'ion-icon',
    never,
    {
        color: { alias: 'color'; required: false };
        flipRtl: { alias: 'flipRtl'; required: false };
        icon: { alias: 'icon'; required: false };
        ios: { alias: 'ios'; required: false };
        lazy: { alias: 'lazy'; required: false };
        md: { alias: 'md'; required: false };
        mode: { alias: 'mode'; required: false };
        name: { alias: 'name'; required: false };
        sanitize: { alias: 'sanitize'; required: false };
        size: { alias: 'size'; required: false };
        src: { alias: 'src'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonIcon, never>;

property z

protected z: NgZone;

class IonImg

class IonImg {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonImgElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonImg,
    'ion-img',
    never,
    {
        alt: { alias: 'alt'; required: false };
        src: { alias: 'src'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonImg, never>;

property z

protected z: NgZone;

class IonInfiniteScroll

class IonInfiniteScroll {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonInfiniteScrollElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonInfiniteScroll,
    'ion-infinite-scroll',
    never,
    {
        disabled: { alias: 'disabled'; required: false };
        position: { alias: 'position'; required: false };
        threshold: { alias: 'threshold'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonInfiniteScroll, never>;

property z

protected z: NgZone;

class IonInfiniteScrollContent

class IonInfiniteScrollContent {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonInfiniteScrollContentElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonInfiniteScrollContent,
    'ion-infinite-scroll-content',
    never,
    {
        loadingSpinner: { alias: 'loadingSpinner'; required: false };
        loadingText: { alias: 'loadingText'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonInfiniteScrollContent, never>;

property z

protected z: NgZone;

class IonInput

class IonInput {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonInputElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonInput,
    'ion-input',
    never,
    {
        autocapitalize: { alias: 'autocapitalize'; required: false };
        autocomplete: { alias: 'autocomplete'; required: false };
        autocorrect: { alias: 'autocorrect'; required: false };
        autofocus: { alias: 'autofocus'; required: false };
        clearInput: { alias: 'clearInput'; required: false };
        clearInputIcon: { alias: 'clearInputIcon'; required: false };
        clearOnEdit: { alias: 'clearOnEdit'; required: false };
        color: { alias: 'color'; required: false };
        counter: { alias: 'counter'; required: false };
        counterFormatter: { alias: 'counterFormatter'; required: false };
        debounce: { alias: 'debounce'; required: false };
        disabled: { alias: 'disabled'; required: false };
        enterkeyhint: { alias: 'enterkeyhint'; required: false };
        errorText: { alias: 'errorText'; required: false };
        fill: { alias: 'fill'; required: false };
        helperText: { alias: 'helperText'; required: false };
        inputmode: { alias: 'inputmode'; required: false };
        label: { alias: 'label'; required: false };
        labelPlacement: { alias: 'labelPlacement'; required: false };
        max: { alias: 'max'; required: false };
        maxlength: { alias: 'maxlength'; required: false };
        min: { alias: 'min'; required: false };
        minlength: { alias: 'minlength'; required: false };
        mode: { alias: 'mode'; required: false };
        multiple: { alias: 'multiple'; required: false };
        name: { alias: 'name'; required: false };
        pattern: { alias: 'pattern'; required: false };
        placeholder: { alias: 'placeholder'; required: false };
        readonly: { alias: 'readonly'; required: false };
        required: { alias: 'required'; required: false };
        shape: { alias: 'shape'; required: false };
        spellcheck: { alias: 'spellcheck'; required: false };
        step: { alias: 'step'; required: false };
        type: { alias: 'type'; required: false };
        value: { alias: 'value'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonInput, never>;

property z

protected z: NgZone;

class IonInputPasswordToggle

class IonInputPasswordToggle {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonInputPasswordToggleElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonInputPasswordToggle,
    'ion-input-password-toggle',
    never,
    {
        color: { alias: 'color'; required: false };
        hideIcon: { alias: 'hideIcon'; required: false };
        mode: { alias: 'mode'; required: false };
        showIcon: { alias: 'showIcon'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonInputPasswordToggle, never>;

property z

protected z: NgZone;

class IonItem

class IonItem {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonItemElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonItem,
    'ion-item',
    never,
    {
        button: { alias: 'button'; required: false };
        color: { alias: 'color'; required: false };
        detail: { alias: 'detail'; required: false };
        detailIcon: { alias: 'detailIcon'; required: false };
        disabled: { alias: 'disabled'; required: false };
        download: { alias: 'download'; required: false };
        href: { alias: 'href'; required: false };
        lines: { alias: 'lines'; required: false };
        mode: { alias: 'mode'; required: false };
        rel: { alias: 'rel'; required: false };
        routerAnimation: { alias: 'routerAnimation'; required: false };
        routerDirection: { alias: 'routerDirection'; required: false };
        target: { alias: 'target'; required: false };
        type: { alias: 'type'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonItem, never>;

property z

protected z: NgZone;

class IonItemDivider

class IonItemDivider {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonItemDividerElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonItemDivider,
    'ion-item-divider',
    never,
    {
        color: { alias: 'color'; required: false };
        mode: { alias: 'mode'; required: false };
        sticky: { alias: 'sticky'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonItemDivider, never>;

property z

protected z: NgZone;

class IonItemGroup

class IonItemGroup {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonItemGroupElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonItemGroup,
    'ion-item-group',
    never,
    {},
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonItemGroup, never>;

property z

protected z: NgZone;

class IonItemOption

class IonItemOption {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonItemOptionElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonItemOption,
    'ion-item-option',
    never,
    {
        color: { alias: 'color'; required: false };
        disabled: { alias: 'disabled'; required: false };
        download: { alias: 'download'; required: false };
        expandable: { alias: 'expandable'; required: false };
        href: { alias: 'href'; required: false };
        mode: { alias: 'mode'; required: false };
        rel: { alias: 'rel'; required: false };
        target: { alias: 'target'; required: false };
        type: { alias: 'type'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonItemOption, never>;

property z

protected z: NgZone;

class IonItemOptions

class IonItemOptions {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonItemOptionsElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonItemOptions,
    'ion-item-options',
    never,
    { side: { alias: 'side'; required: false } },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonItemOptions, never>;

property z

protected z: NgZone;

class IonItemSliding

class IonItemSliding {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonItemSlidingElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonItemSliding,
    'ion-item-sliding',
    never,
    { disabled: { alias: 'disabled'; required: false } },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonItemSliding, never>;

property z

protected z: NgZone;

class IonLabel

class IonLabel {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonLabelElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonLabel,
    'ion-label',
    never,
    {
        color: { alias: 'color'; required: false };
        mode: { alias: 'mode'; required: false };
        position: { alias: 'position'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonLabel, never>;

property z

protected z: NgZone;

class IonList

class IonList {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonListElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonList,
    'ion-list',
    never,
    {
        inset: { alias: 'inset'; required: false };
        lines: { alias: 'lines'; required: false };
        mode: { alias: 'mode'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonList, never>;

property z

protected z: NgZone;

class IonListHeader

class IonListHeader {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonListHeaderElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonListHeader,
    'ion-list-header',
    never,
    {
        color: { alias: 'color'; required: false };
        lines: { alias: 'lines'; required: false };
        mode: { alias: 'mode'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonListHeader, never>;

property z

protected z: NgZone;

class IonLoading

class IonLoading {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonLoadingElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonLoading,
    'ion-loading',
    never,
    {
        animated: { alias: 'animated'; required: false };
        backdropDismiss: { alias: 'backdropDismiss'; required: false };
        cssClass: { alias: 'cssClass'; required: false };
        duration: { alias: 'duration'; required: false };
        enterAnimation: { alias: 'enterAnimation'; required: false };
        htmlAttributes: { alias: 'htmlAttributes'; required: false };
        isOpen: { alias: 'isOpen'; required: false };
        keyboardClose: { alias: 'keyboardClose'; required: false };
        leaveAnimation: { alias: 'leaveAnimation'; required: false };
        message: { alias: 'message'; required: false };
        mode: { alias: 'mode'; required: false };
        showBackdrop: { alias: 'showBackdrop'; required: false };
        spinner: { alias: 'spinner'; required: false };
        translucent: { alias: 'translucent'; required: false };
        trigger: { alias: 'trigger'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonLoading, never>;

property z

protected z: NgZone;

class IonMaxValidator

class IonMaxValidator extends MaxValidator {}

property ɵdir

static ɵdir: i0.ɵɵDirectiveDeclaration<
    IonMaxValidator,
    'ion-input[type=number][max][formControlName],ion-input[type=number][max][formControl],ion-input[type=number][max][ngModel]',
    never,
    {},
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonMaxValidator, never>;

class IonMenu

class IonMenu {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonMenuElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonMenu,
    'ion-menu',
    never,
    {
        contentId: { alias: 'contentId'; required: false };
        disabled: { alias: 'disabled'; required: false };
        maxEdgeStart: { alias: 'maxEdgeStart'; required: false };
        menuId: { alias: 'menuId'; required: false };
        side: { alias: 'side'; required: false };
        swipeGesture: { alias: 'swipeGesture'; required: false };
        type: { alias: 'type'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonMenu, never>;

property z

protected z: NgZone;

class IonMenuButton

class IonMenuButton {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonMenuButtonElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonMenuButton,
    'ion-menu-button',
    never,
    {
        autoHide: { alias: 'autoHide'; required: false };
        color: { alias: 'color'; required: false };
        disabled: { alias: 'disabled'; required: false };
        menu: { alias: 'menu'; required: false };
        mode: { alias: 'mode'; required: false };
        type: { alias: 'type'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonMenuButton, never>;

property z

protected z: NgZone;

class IonMenuToggle

class IonMenuToggle {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonMenuToggleElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonMenuToggle,
    'ion-menu-toggle',
    never,
    {
        autoHide: { alias: 'autoHide'; required: false };
        menu: { alias: 'menu'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonMenuToggle, never>;

property z

protected z: NgZone;

class IonMinValidator

class IonMinValidator extends MinValidator {}

property ɵdir

static ɵdir: i0.ɵɵDirectiveDeclaration<
    IonMinValidator,
    'ion-input[type=number][min][formControlName],ion-input[type=number][min][formControl],ion-input[type=number][min][ngModel]',
    never,
    {},
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonMinValidator, never>;

class IonModal

class IonModal extends IonModalBase {}

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonModal,
    'ion-modal',
    never,
    {},
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonModal, never>;

class IonNav

class IonNav extends IonNavBase {}

constructor

constructor(
    ref: ElementRef,
    environmentInjector: EnvironmentInjector,
    injector: Injector,
    angularDelegate: AngularDelegate,
    z: NgZone,
    c: ChangeDetectorRef
);

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonNav,
    'ion-nav',
    never,
    {},
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonNav, never>;

class IonNavLink

class IonNavLink {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonNavLinkElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonNavLink,
    'ion-nav-link',
    never,
    {
        component: { alias: 'component'; required: false };
        componentProps: { alias: 'componentProps'; required: false };
        routerAnimation: { alias: 'routerAnimation'; required: false };
        routerDirection: { alias: 'routerDirection'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonNavLink, never>;

property z

protected z: NgZone;

class IonNote

class IonNote {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonNoteElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonNote,
    'ion-note',
    never,
    {
        color: { alias: 'color'; required: false };
        mode: { alias: 'mode'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonNote, never>;

property z

protected z: NgZone;

class IonPicker

class IonPicker {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonPickerElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonPicker,
    'ion-picker',
    never,
    { mode: { alias: 'mode'; required: false } },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonPicker, never>;

property z

protected z: NgZone;

class IonPickerColumn

class IonPickerColumn {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonPickerColumnElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonPickerColumn,
    'ion-picker-column',
    never,
    {
        color: { alias: 'color'; required: false };
        disabled: { alias: 'disabled'; required: false };
        mode: { alias: 'mode'; required: false };
        value: { alias: 'value'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonPickerColumn, never>;

property z

protected z: NgZone;

class IonPickerColumnOption

class IonPickerColumnOption {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonPickerColumnOptionElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonPickerColumnOption,
    'ion-picker-column-option',
    never,
    {
        color: { alias: 'color'; required: false };
        disabled: { alias: 'disabled'; required: false };
        value: { alias: 'value'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonPickerColumnOption, never>;

property z

protected z: NgZone;

class IonPickerLegacy

class IonPickerLegacy {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonPickerLegacyElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonPickerLegacy,
    'ion-picker-legacy',
    never,
    {
        animated: { alias: 'animated'; required: false };
        backdropDismiss: { alias: 'backdropDismiss'; required: false };
        buttons: { alias: 'buttons'; required: false };
        columns: { alias: 'columns'; required: false };
        cssClass: { alias: 'cssClass'; required: false };
        duration: { alias: 'duration'; required: false };
        enterAnimation: { alias: 'enterAnimation'; required: false };
        htmlAttributes: { alias: 'htmlAttributes'; required: false };
        isOpen: { alias: 'isOpen'; required: false };
        keyboardClose: { alias: 'keyboardClose'; required: false };
        leaveAnimation: { alias: 'leaveAnimation'; required: false };
        mode: { alias: 'mode'; required: false };
        showBackdrop: { alias: 'showBackdrop'; required: false };
        trigger: { alias: 'trigger'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonPickerLegacy, never>;

property z

protected z: NgZone;

class IonPopover

class IonPopover extends IonPopoverBase {}

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonPopover,
    'ion-popover',
    never,
    {},
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonPopover, never>;

class IonProgressBar

class IonProgressBar {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonProgressBarElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonProgressBar,
    'ion-progress-bar',
    never,
    {
        buffer: { alias: 'buffer'; required: false };
        color: { alias: 'color'; required: false };
        mode: { alias: 'mode'; required: false };
        reversed: { alias: 'reversed'; required: false };
        type: { alias: 'type'; required: false };
        value: { alias: 'value'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonProgressBar, never>;

property z

protected z: NgZone;

class IonRadio

class IonRadio {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonRadioElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonRadio,
    'ion-radio',
    never,
    {
        alignment: { alias: 'alignment'; required: false };
        color: { alias: 'color'; required: false };
        disabled: { alias: 'disabled'; required: false };
        justify: { alias: 'justify'; required: false };
        labelPlacement: { alias: 'labelPlacement'; required: false };
        mode: { alias: 'mode'; required: false };
        name: { alias: 'name'; required: false };
        value: { alias: 'value'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonRadio, never>;

property z

protected z: NgZone;

class IonRadioGroup

class IonRadioGroup {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonRadioGroupElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonRadioGroup,
    'ion-radio-group',
    never,
    {
        allowEmptySelection: { alias: 'allowEmptySelection'; required: false };
        compareWith: { alias: 'compareWith'; required: false };
        errorText: { alias: 'errorText'; required: false };
        helperText: { alias: 'helperText'; required: false };
        name: { alias: 'name'; required: false };
        value: { alias: 'value'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonRadioGroup, never>;

property z

protected z: NgZone;

class IonRange

class IonRange {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonRangeElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonRange,
    'ion-range',
    never,
    {
        activeBarStart: { alias: 'activeBarStart'; required: false };
        color: { alias: 'color'; required: false };
        debounce: { alias: 'debounce'; required: false };
        disabled: { alias: 'disabled'; required: false };
        dualKnobs: { alias: 'dualKnobs'; required: false };
        label: { alias: 'label'; required: false };
        labelPlacement: { alias: 'labelPlacement'; required: false };
        max: { alias: 'max'; required: false };
        min: { alias: 'min'; required: false };
        mode: { alias: 'mode'; required: false };
        name: { alias: 'name'; required: false };
        pin: { alias: 'pin'; required: false };
        pinFormatter: { alias: 'pinFormatter'; required: false };
        snaps: { alias: 'snaps'; required: false };
        step: { alias: 'step'; required: false };
        ticks: { alias: 'ticks'; required: false };
        value: { alias: 'value'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonRange, never>;

property z

protected z: NgZone;

class IonRefresher

class IonRefresher {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonRefresherElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonRefresher,
    'ion-refresher',
    never,
    {
        closeDuration: { alias: 'closeDuration'; required: false };
        disabled: { alias: 'disabled'; required: false };
        mode: { alias: 'mode'; required: false };
        pullFactor: { alias: 'pullFactor'; required: false };
        pullMax: { alias: 'pullMax'; required: false };
        pullMin: { alias: 'pullMin'; required: false };
        snapbackDuration: { alias: 'snapbackDuration'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonRefresher, never>;

property z

protected z: NgZone;

class IonRefresherContent

class IonRefresherContent {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonRefresherContentElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonRefresherContent,
    'ion-refresher-content',
    never,
    {
        pullingIcon: { alias: 'pullingIcon'; required: false };
        pullingText: { alias: 'pullingText'; required: false };
        refreshingSpinner: { alias: 'refreshingSpinner'; required: false };
        refreshingText: { alias: 'refreshingText'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonRefresherContent, never>;

property z

protected z: NgZone;

class IonReorder

class IonReorder {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonReorderElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonReorder,
    'ion-reorder',
    never,
    {},
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonReorder, never>;

property z

protected z: NgZone;

class IonReorderGroup

class IonReorderGroup {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonReorderGroupElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonReorderGroup,
    'ion-reorder-group',
    never,
    { disabled: { alias: 'disabled'; required: false } },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonReorderGroup, never>;

property z

protected z: NgZone;

class IonRippleEffect

class IonRippleEffect {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonRippleEffectElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonRippleEffect,
    'ion-ripple-effect',
    never,
    { type: { alias: 'type'; required: false } },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonRippleEffect, never>;

property z

protected z: NgZone;

class IonRouterOutlet

class IonRouterOutlet extends IonRouterOutletBase {}

constructor

constructor(
    name: string,
    tabs: string,
    commonLocation: Location,
    elementRef: ElementRef,
    router: Router,
    zone: NgZone,
    activatedRoute: ActivatedRoute,
    parentOutlet?: IonRouterOutlet
);

We need to pass in the correct instance of IonRouterOutlet otherwise parentOutlet will be null in a nested outlet context. This results in APIs such as NavController.pop not working in nested outlets because the parent outlet cannot be found.

property outletContent

outletContent: ViewContainerRef;

static: true must be set so the query results are resolved before change detection runs. Otherwise, the view container ref will be ion-router-outlet instead of ng-container, and the first view will be added as a sibling of ion-router-outlet instead of a child.

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonRouterOutlet,
    'ion-router-outlet',
    never,
    {},
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<
    IonRouterOutlet,
    [
        { attribute: 'name' },
        { attribute: 'tabs'; optional: true },
        null,
        null,
        null,
        null,
        null,
        { optional: true; skipSelf: true }
    ]
>;

property parentOutlet

readonly parentOutlet?: IonRouterOutlet;

class IonRow

class IonRow {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonRowElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonRow,
    'ion-row',
    never,
    {},
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonRow, never>;

property z

protected z: NgZone;

class IonSearchbar

class IonSearchbar {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonSearchbarElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonSearchbar,
    'ion-searchbar',
    never,
    {
        animated: { alias: 'animated'; required: false };
        autocapitalize: { alias: 'autocapitalize'; required: false };
        autocomplete: { alias: 'autocomplete'; required: false };
        autocorrect: { alias: 'autocorrect'; required: false };
        cancelButtonIcon: { alias: 'cancelButtonIcon'; required: false };
        cancelButtonText: { alias: 'cancelButtonText'; required: false };
        clearIcon: { alias: 'clearIcon'; required: false };
        color: { alias: 'color'; required: false };
        debounce: { alias: 'debounce'; required: false };
        disabled: { alias: 'disabled'; required: false };
        enterkeyhint: { alias: 'enterkeyhint'; required: false };
        inputmode: { alias: 'inputmode'; required: false };
        maxlength: { alias: 'maxlength'; required: false };
        minlength: { alias: 'minlength'; required: false };
        mode: { alias: 'mode'; required: false };
        name: { alias: 'name'; required: false };
        placeholder: { alias: 'placeholder'; required: false };
        searchIcon: { alias: 'searchIcon'; required: false };
        showCancelButton: { alias: 'showCancelButton'; required: false };
        showClearButton: { alias: 'showClearButton'; required: false };
        spellcheck: { alias: 'spellcheck'; required: false };
        type: { alias: 'type'; required: false };
        value: { alias: 'value'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonSearchbar, never>;

property z

protected z: NgZone;

class IonSegment

class IonSegment {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonSegmentElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonSegment,
    'ion-segment',
    never,
    {
        color: { alias: 'color'; required: false };
        disabled: { alias: 'disabled'; required: false };
        mode: { alias: 'mode'; required: false };
        scrollable: { alias: 'scrollable'; required: false };
        selectOnFocus: { alias: 'selectOnFocus'; required: false };
        swipeGesture: { alias: 'swipeGesture'; required: false };
        value: { alias: 'value'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonSegment, never>;

property z

protected z: NgZone;

class IonSegmentButton

class IonSegmentButton {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonSegmentButtonElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonSegmentButton,
    'ion-segment-button',
    never,
    {
        contentId: { alias: 'contentId'; required: false };
        disabled: { alias: 'disabled'; required: false };
        layout: { alias: 'layout'; required: false };
        mode: { alias: 'mode'; required: false };
        type: { alias: 'type'; required: false };
        value: { alias: 'value'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonSegmentButton, never>;

property z

protected z: NgZone;

class IonSegmentContent

class IonSegmentContent {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonSegmentContentElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonSegmentContent,
    'ion-segment-content',
    never,
    {},
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonSegmentContent, never>;

property z

protected z: NgZone;

class IonSegmentView

class IonSegmentView {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonSegmentViewElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonSegmentView,
    'ion-segment-view',
    never,
    { disabled: { alias: 'disabled'; required: false } },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonSegmentView, never>;

property z

protected z: NgZone;

class IonSelect

class IonSelect {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonSelectElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonSelect,
    'ion-select',
    never,
    {
        cancelText: { alias: 'cancelText'; required: false };
        color: { alias: 'color'; required: false };
        compareWith: { alias: 'compareWith'; required: false };
        disabled: { alias: 'disabled'; required: false };
        errorText: { alias: 'errorText'; required: false };
        expandedIcon: { alias: 'expandedIcon'; required: false };
        fill: { alias: 'fill'; required: false };
        helperText: { alias: 'helperText'; required: false };
        interface: { alias: 'interface'; required: false };
        interfaceOptions: { alias: 'interfaceOptions'; required: false };
        justify: { alias: 'justify'; required: false };
        label: { alias: 'label'; required: false };
        labelPlacement: { alias: 'labelPlacement'; required: false };
        mode: { alias: 'mode'; required: false };
        multiple: { alias: 'multiple'; required: false };
        name: { alias: 'name'; required: false };
        okText: { alias: 'okText'; required: false };
        placeholder: { alias: 'placeholder'; required: false };
        required: { alias: 'required'; required: false };
        selectedText: { alias: 'selectedText'; required: false };
        shape: { alias: 'shape'; required: false };
        toggleIcon: { alias: 'toggleIcon'; required: false };
        value: { alias: 'value'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonSelect, never>;

property z

protected z: NgZone;

class IonSelectModal

class IonSelectModal {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonSelectModalElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonSelectModal,
    'ion-select-modal',
    never,
    {
        header: { alias: 'header'; required: false };
        multiple: { alias: 'multiple'; required: false };
        options: { alias: 'options'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonSelectModal, never>;

property z

protected z: NgZone;

class IonSelectOption

class IonSelectOption {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonSelectOptionElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonSelectOption,
    'ion-select-option',
    never,
    {
        disabled: { alias: 'disabled'; required: false };
        value: { alias: 'value'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonSelectOption, never>;

property z

protected z: NgZone;

class IonSkeletonText

class IonSkeletonText {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonSkeletonTextElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonSkeletonText,
    'ion-skeleton-text',
    never,
    { animated: { alias: 'animated'; required: false } },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonSkeletonText, never>;

property z

protected z: NgZone;

class IonSpinner

class IonSpinner {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonSpinnerElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonSpinner,
    'ion-spinner',
    never,
    {
        color: { alias: 'color'; required: false };
        duration: { alias: 'duration'; required: false };
        name: { alias: 'name'; required: false };
        paused: { alias: 'paused'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonSpinner, never>;

property z

protected z: NgZone;

class IonSplitPane

class IonSplitPane {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonSplitPaneElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonSplitPane,
    'ion-split-pane',
    never,
    {
        contentId: { alias: 'contentId'; required: false };
        disabled: { alias: 'disabled'; required: false };
        when: { alias: 'when'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonSplitPane, never>;

property z

protected z: NgZone;

class IonTab

class IonTab {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonTabElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonTab,
    'ion-tab',
    never,
    {
        component: { alias: 'component'; required: false };
        tab: { alias: 'tab'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonTab, never>;

property z

protected z: NgZone;

class IonTabBar

class IonTabBar {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonTabBarElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonTabBar,
    'ion-tab-bar',
    never,
    {
        color: { alias: 'color'; required: false };
        mode: { alias: 'mode'; required: false };
        selectedTab: { alias: 'selectedTab'; required: false };
        translucent: { alias: 'translucent'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonTabBar, never>;

property z

protected z: NgZone;

class IonTabButton

class IonTabButton {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonTabButtonElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonTabButton,
    'ion-tab-button',
    never,
    {
        disabled: { alias: 'disabled'; required: false };
        download: { alias: 'download'; required: false };
        href: { alias: 'href'; required: false };
        layout: { alias: 'layout'; required: false };
        mode: { alias: 'mode'; required: false };
        rel: { alias: 'rel'; required: false };
        selected: { alias: 'selected'; required: false };
        tab: { alias: 'tab'; required: false };
        target: { alias: 'target'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonTabButton, never>;

property z

protected z: NgZone;

class IonTabs

class IonTabs extends IonTabsBase {}

property outlet

outlet: IonRouterOutlet;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonTabs,
    'ion-tabs',
    never,
    {},
    {},
    ['tabBar', 'tabBars', 'tabs'],
    ['[slot=top]', 'ion-tab', '*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonTabs, never>;

property tabBar

tabBar: IonTabBar;

property tabBars

tabBars: QueryList<IonTabBar>;

property tabs

tabs: QueryList<IonTab>;

class IonText

class IonText {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonTextElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonText,
    'ion-text',
    never,
    {
        color: { alias: 'color'; required: false };
        mode: { alias: 'mode'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonText, never>;

property z

protected z: NgZone;

class IonTextarea

class IonTextarea {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonTextareaElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonTextarea,
    'ion-textarea',
    never,
    {
        autoGrow: { alias: 'autoGrow'; required: false };
        autocapitalize: { alias: 'autocapitalize'; required: false };
        autofocus: { alias: 'autofocus'; required: false };
        clearOnEdit: { alias: 'clearOnEdit'; required: false };
        color: { alias: 'color'; required: false };
        cols: { alias: 'cols'; required: false };
        counter: { alias: 'counter'; required: false };
        counterFormatter: { alias: 'counterFormatter'; required: false };
        debounce: { alias: 'debounce'; required: false };
        disabled: { alias: 'disabled'; required: false };
        enterkeyhint: { alias: 'enterkeyhint'; required: false };
        errorText: { alias: 'errorText'; required: false };
        fill: { alias: 'fill'; required: false };
        helperText: { alias: 'helperText'; required: false };
        inputmode: { alias: 'inputmode'; required: false };
        label: { alias: 'label'; required: false };
        labelPlacement: { alias: 'labelPlacement'; required: false };
        maxlength: { alias: 'maxlength'; required: false };
        minlength: { alias: 'minlength'; required: false };
        mode: { alias: 'mode'; required: false };
        name: { alias: 'name'; required: false };
        placeholder: { alias: 'placeholder'; required: false };
        readonly: { alias: 'readonly'; required: false };
        required: { alias: 'required'; required: false };
        rows: { alias: 'rows'; required: false };
        shape: { alias: 'shape'; required: false };
        spellcheck: { alias: 'spellcheck'; required: false };
        value: { alias: 'value'; required: false };
        wrap: { alias: 'wrap'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonTextarea, never>;

property z

protected z: NgZone;

class IonThumbnail

class IonThumbnail {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonThumbnailElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonThumbnail,
    'ion-thumbnail',
    never,
    {},
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonThumbnail, never>;

property z

protected z: NgZone;

class IonTitle

class IonTitle {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonTitleElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonTitle,
    'ion-title',
    never,
    {
        color: { alias: 'color'; required: false };
        size: { alias: 'size'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonTitle, never>;

property z

protected z: NgZone;

class IonToast

class IonToast {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonToastElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonToast,
    'ion-toast',
    never,
    {
        animated: { alias: 'animated'; required: false };
        buttons: { alias: 'buttons'; required: false };
        color: { alias: 'color'; required: false };
        cssClass: { alias: 'cssClass'; required: false };
        duration: { alias: 'duration'; required: false };
        enterAnimation: { alias: 'enterAnimation'; required: false };
        header: { alias: 'header'; required: false };
        htmlAttributes: { alias: 'htmlAttributes'; required: false };
        icon: { alias: 'icon'; required: false };
        isOpen: { alias: 'isOpen'; required: false };
        keyboardClose: { alias: 'keyboardClose'; required: false };
        layout: { alias: 'layout'; required: false };
        leaveAnimation: { alias: 'leaveAnimation'; required: false };
        message: { alias: 'message'; required: false };
        mode: { alias: 'mode'; required: false };
        position: { alias: 'position'; required: false };
        positionAnchor: { alias: 'positionAnchor'; required: false };
        swipeGesture: { alias: 'swipeGesture'; required: false };
        translucent: { alias: 'translucent'; required: false };
        trigger: { alias: 'trigger'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonToast, never>;

property z

protected z: NgZone;

class IonToggle

class IonToggle {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonToggleElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonToggle,
    'ion-toggle',
    never,
    {
        alignment: { alias: 'alignment'; required: false };
        checked: { alias: 'checked'; required: false };
        color: { alias: 'color'; required: false };
        disabled: { alias: 'disabled'; required: false };
        enableOnOffLabels: { alias: 'enableOnOffLabels'; required: false };
        errorText: { alias: 'errorText'; required: false };
        helperText: { alias: 'helperText'; required: false };
        justify: { alias: 'justify'; required: false };
        labelPlacement: { alias: 'labelPlacement'; required: false };
        mode: { alias: 'mode'; required: false };
        name: { alias: 'name'; required: false };
        required: { alias: 'required'; required: false };
        value: { alias: 'value'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonToggle, never>;

property z

protected z: NgZone;

class IonToolbar

class IonToolbar {}

constructor

constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);

property el

protected el: HTMLIonToolbarElement;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    IonToolbar,
    'ion-toolbar',
    never,
    {
        color: { alias: 'color'; required: false };
        mode: { alias: 'mode'; required: false };
    },
    {},
    never,
    ['*'],
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<IonToolbar, never>;

property z

protected z: NgZone;

class LoadingController

class LoadingController extends OverlayBaseController<
    LoadingOptions,
    HTMLIonLoadingElement
> {}

constructor

constructor();

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<LoadingController, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<LoadingController>;

class MenuController

class MenuController extends MenuControllerBase {}

constructor

constructor();

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<MenuController, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<MenuController>;

class ModalController

class ModalController extends OverlayBaseController<
    ModalOptions,
    HTMLIonModalElement
> {}

constructor

constructor();

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<ModalController, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<ModalController>;

method create

create: (opts: ModalOptions) => Promise<HTMLIonModalElement>;

class NumericValueAccessor

class NumericValueAccessorDirective extends ValueAccessor {}

constructor

constructor(injector: Injector, el: ElementRef<any>);

property ɵdir

static ɵdir: i0.ɵɵDirectiveDeclaration<
    NumericValueAccessorDirective,
    'ion-input[type=number],ion-range',
    never,
    {},
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<NumericValueAccessorDirective, never>;

method handleInputEvent

handleInputEvent: (el: HTMLIonInputElement | HTMLIonRangeElement) => void;

method registerOnChange

registerOnChange: (fn: (_: number | null) => void) => void;

class PickerController

class PickerController extends OverlayBaseController<
    PickerOptions,
    HTMLIonPickerLegacyElement
> {}

Deprecated
Use the inline ion-picker component instead.

constructor

constructor();

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<PickerController, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<PickerController>;

class PopoverController

class PopoverController extends OverlayBaseController<
    PopoverOptions,
    HTMLIonPopoverElement
> {}

constructor

constructor();

method create

create: (opts: PopoverOptions) => Promise<HTMLIonPopoverElement>;

class RouterLinkDelegate

class RouterLinkDelegateDirective extends RouterLinkDelegateBase {}

Adds support for Ionic routing directions and animations to the base Angular router link directive.
When the router link is clicked, the directive will assign the direction and animation so that the routing integration will transition correctly.

property ɵdir

static ɵdir: i0.ɵɵDirectiveDeclaration<
    RouterLinkDelegateDirective,
    ':not(a):not(area)[routerLink]',
    never,
    {},
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<RouterLinkDelegateDirective, never>;

class RouterLinkWithHrefDelegate

class RouterLinkWithHrefDelegateDirective extends RouterLinkHrefDelegateBase {}

property ɵdir

static ɵdir: i0.ɵɵDirectiveDeclaration<
    RouterLinkWithHrefDelegateDirective,
    'a[routerLink],area[routerLink]',
    never,
    {},
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<RouterLinkWithHrefDelegateDirective, never>;

class SelectValueAccessor

class SelectValueAccessorDirective extends ValueAccessor {}

constructor

constructor(injector: Injector, el: ElementRef);

property ɵdir

static ɵdir: i0.ɵɵDirectiveDeclaration<
    SelectValueAccessorDirective,
    'ion-select, ion-radio-group, ion-segment, ion-datetime',
    never,
    {},
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<SelectValueAccessorDirective, never>;

class TextValueAccessor

class TextValueAccessorDirective extends ValueAccessor {}

constructor

constructor(injector: Injector, el: ElementRef);

property ɵdir

static ɵdir: i0.ɵɵDirectiveDeclaration<
    TextValueAccessorDirective,
    'ion-input:not([type=number]),ion-textarea,ion-searchbar',
    never,
    {},
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<TextValueAccessorDirective, never>;

class ToastController

class ToastController extends OverlayBaseController<
    ToastOptions,
    HTMLIonToastElement
> {}

constructor

constructor();

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<ToastController, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<ToastController>;

Interfaces

interface IonAccordion

interface IonAccordion extends Components.IonAccordion {}

interface IonAccordionGroup

interface IonAccordionGroup extends Components.IonAccordionGroup {}

property ionChange

ionChange: EventEmitter<
    CustomEvent<IIonAccordionGroupAccordionGroupChangeEventDetail>
>;

Emitted when the value property has changed as a result of a user action such as a click.
This event will not emit when programmatically setting the value property.

interface IonActionSheet

interface IonActionSheet extends Components.IonActionSheet {}

property didDismiss

didDismiss: EventEmitter<CustomEvent<IIonActionSheetOverlayEventDetail>>;

Emitted after the action sheet has dismissed. Shorthand for ionActionSheetDidDismiss.

property didPresent

didPresent: EventEmitter<CustomEvent<void>>;

Emitted after the action sheet has presented. Shorthand for ionActionSheetWillDismiss.

property ionActionSheetDidDismiss

ionActionSheetDidDismiss: EventEmitter<
    CustomEvent<IIonActionSheetOverlayEventDetail>
>;

Emitted after the action sheet has dismissed.

property ionActionSheetDidPresent

ionActionSheetDidPresent: EventEmitter<CustomEvent<void>>;

Emitted after the action sheet has presented.

property ionActionSheetWillDismiss

ionActionSheetWillDismiss: EventEmitter<
    CustomEvent<IIonActionSheetOverlayEventDetail>
>;

Emitted before the action sheet has dismissed.

property ionActionSheetWillPresent

ionActionSheetWillPresent: EventEmitter<CustomEvent<void>>;

Emitted before the action sheet has presented.

property willDismiss

willDismiss: EventEmitter<CustomEvent<IIonActionSheetOverlayEventDetail>>;

Emitted before the action sheet has dismissed. Shorthand for ionActionSheetWillDismiss.

property willPresent

willPresent: EventEmitter<CustomEvent<void>>;

Emitted before the action sheet has presented. Shorthand for ionActionSheetWillPresent.

interface IonAlert

interface IonAlert extends Components.IonAlert {}

property didDismiss

didDismiss: EventEmitter<CustomEvent<IIonAlertOverlayEventDetail>>;

Emitted after the alert has dismissed. Shorthand for ionAlertDidDismiss.

property didPresent

didPresent: EventEmitter<CustomEvent<void>>;

Emitted after the alert has presented. Shorthand for ionAlertWillDismiss.

property ionAlertDidDismiss

ionAlertDidDismiss: EventEmitter<CustomEvent<IIonAlertOverlayEventDetail>>;

Emitted after the alert has dismissed.

property ionAlertDidPresent

ionAlertDidPresent: EventEmitter<CustomEvent<void>>;

Emitted after the alert has presented.

property ionAlertWillDismiss

ionAlertWillDismiss: EventEmitter<CustomEvent<IIonAlertOverlayEventDetail>>;

Emitted before the alert has dismissed.

property ionAlertWillPresent

ionAlertWillPresent: EventEmitter<CustomEvent<void>>;

Emitted before the alert has presented.

property willDismiss

willDismiss: EventEmitter<CustomEvent<IIonAlertOverlayEventDetail>>;

Emitted before the alert has dismissed. Shorthand for ionAlertWillDismiss.

property willPresent

willPresent: EventEmitter<CustomEvent<void>>;

Emitted before the alert has presented. Shorthand for ionAlertWillPresent.

interface IonApp

interface IonApp extends Components.IonApp {}

interface IonAvatar

interface IonAvatar extends Components.IonAvatar {}

interface IonBackdrop

interface IonBackdrop extends Components.IonBackdrop {}

property ionBackdropTap

ionBackdropTap: EventEmitter<CustomEvent<void>>;

Emitted when the backdrop is tapped.

interface IonBadge

interface IonBadge extends Components.IonBadge {}

interface IonBreadcrumb

interface IonBreadcrumb extends Components.IonBreadcrumb {}

property ionBlur

ionBlur: EventEmitter<CustomEvent<void>>;

Emitted when the breadcrumb loses focus.

property ionFocus

ionFocus: EventEmitter<CustomEvent<void>>;

Emitted when the breadcrumb has focus.

interface IonBreadcrumbs

interface IonBreadcrumbs extends Components.IonBreadcrumbs {}

property ionCollapsedClick

ionCollapsedClick: EventEmitter<
    CustomEvent<IIonBreadcrumbsBreadcrumbCollapsedClickEventDetail>
>;

Emitted when the collapsed indicator is clicked on.

interface IonButton

interface IonButton extends Components.IonButton {}

property ionBlur

ionBlur: EventEmitter<CustomEvent<void>>;

Emitted when the button loses focus.

property ionFocus

ionFocus: EventEmitter<CustomEvent<void>>;

Emitted when the button has focus.

interface IonButtons

interface IonButtons extends Components.IonButtons {}

interface IonCard

interface IonCard extends Components.IonCard {}

interface IonCardContent

interface IonCardContent extends Components.IonCardContent {}

interface IonCardHeader

interface IonCardHeader extends Components.IonCardHeader {}

interface IonCardSubtitle

interface IonCardSubtitle extends Components.IonCardSubtitle {}

interface IonCardTitle

interface IonCardTitle extends Components.IonCardTitle {}

interface IonCheckbox

interface IonCheckbox extends Components.IonCheckbox {}

property ionBlur

ionBlur: EventEmitter<CustomEvent<void>>;

Emitted when the checkbox loses focus.

property ionChange

ionChange: EventEmitter<CustomEvent<IIonCheckboxCheckboxChangeEventDetail>>;

Emitted when the checked property has changed as a result of a user action such as a click.
This event will not emit when programmatically setting the checked property.

property ionFocus

ionFocus: EventEmitter<CustomEvent<void>>;

Emitted when the checkbox has focus.

interface IonChip

interface IonChip extends Components.IonChip {}

interface IonCol

interface IonCol extends Components.IonCol {}

interface IonContent

interface IonContent extends Components.IonContent {}

property ionScroll

ionScroll: EventEmitter<CustomEvent<IIonContentScrollDetail>>;

Emitted while scrolling. This event is disabled by default. Set scrollEvents to true to enable.

property ionScrollEnd

ionScrollEnd: EventEmitter<CustomEvent<IIonContentScrollBaseDetail>>;

Emitted when the scroll has ended. This event is disabled by default. Set scrollEvents to true to enable.

property ionScrollStart

ionScrollStart: EventEmitter<CustomEvent<IIonContentScrollBaseDetail>>;

Emitted when the scroll has started. This event is disabled by default. Set scrollEvents to true to enable.

interface IonDatetime

interface IonDatetime extends Components.IonDatetime {}

property ionBlur

ionBlur: EventEmitter<CustomEvent<void>>;

Emitted when the datetime loses focus.

property ionCancel

ionCancel: EventEmitter<CustomEvent<void>>;

Emitted when the datetime selection was cancelled.

property ionChange

ionChange: EventEmitter<CustomEvent<IIonDatetimeDatetimeChangeEventDetail>>;

Emitted when the value (selected date) has changed.
This event will not emit when programmatically setting the value property.

property ionFocus

ionFocus: EventEmitter<CustomEvent<void>>;

Emitted when the datetime has focus.

interface IonDatetimeButton

interface IonDatetimeButton extends Components.IonDatetimeButton {}

interface IonFab

interface IonFab extends Components.IonFab {}

interface IonFabButton

interface IonFabButton extends Components.IonFabButton {}

property ionBlur

ionBlur: EventEmitter<CustomEvent<void>>;

Emitted when the button loses focus.

property ionFocus

ionFocus: EventEmitter<CustomEvent<void>>;

Emitted when the button has focus.

interface IonFabList

interface IonFabList extends Components.IonFabList {}

interface IonFooter

interface IonFooter extends Components.IonFooter {}

interface IonGrid

interface IonGrid extends Components.IonGrid {}

interface IonHeader

interface IonHeader extends Components.IonHeader {}

interface IonIcon

interface IonIcon extends Components.IonIcon {}

interface IonImg

interface IonImg extends Components.IonImg {}

property ionError

ionError: EventEmitter<CustomEvent<void>>;

Emitted when the img fails to load

property ionImgDidLoad

ionImgDidLoad: EventEmitter<CustomEvent<void>>;

Emitted when the image has finished loading

property ionImgWillLoad

ionImgWillLoad: EventEmitter<CustomEvent<void>>;

Emitted when the img src has been set

interface IonInfiniteScroll

interface IonInfiniteScroll extends Components.IonInfiniteScroll {}

property ionInfinite

ionInfinite: EventEmitter<CustomEvent<void>>;

Emitted when the scroll reaches the threshold distance. From within your infinite handler, you must call the infinite scroll's complete() method when your async operation has completed.

interface IonInfiniteScrollContent

interface IonInfiniteScrollContent extends Components.IonInfiniteScrollContent {}

interface IonInput

interface IonInput extends Components.IonInput {}

property ionBlur

ionBlur: EventEmitter<CustomEvent<FocusEvent>>;

Emitted when the input loses focus.

property ionChange

ionChange: EventEmitter<CustomEvent<IIonInputInputChangeEventDetail>>;

The ionChange event is fired when the user modifies the input's value. Unlike the ionInput event, the ionChange event is only fired when changes are committed, not as the user types.
Depending on the way the users interacts with the element, the ionChange event fires at a different moment: - When the user commits the change explicitly (e.g. by selecting a date from a date picker for <ion-input type="date">, pressing the "Enter" key, etc.). - When the element loses focus after its value has changed: for elements where the user's interaction is typing.
This event will not emit when programmatically setting the value property.

property ionFocus

ionFocus: EventEmitter<CustomEvent<FocusEvent>>;

Emitted when the input has focus.

property ionInput

ionInput: EventEmitter<CustomEvent<IIonInputInputInputEventDetail>>;

The ionInput event is fired each time the user modifies the input's value. Unlike the ionChange event, the ionInput event is fired for each alteration to the input's value. This typically happens for each keystroke as the user types.
For elements that accept text input (type=text, type=tel, etc.), the interface is [InputEvent](https://developer.mozilla.org/en-US/docs/Web/API/InputEvent); for others, the interface is [Event](https://developer.mozilla.org/en-US/docs/Web/API/Event). If the input is cleared on edit, the type is null.

interface IonInputPasswordToggle

interface IonInputPasswordToggle extends Components.IonInputPasswordToggle {}

interface IonItem

interface IonItem extends Components.IonItem {}

interface IonItemDivider

interface IonItemDivider extends Components.IonItemDivider {}

interface IonItemGroup

interface IonItemGroup extends Components.IonItemGroup {}

interface IonItemOption

interface IonItemOption extends Components.IonItemOption {}

interface IonItemOptions

interface IonItemOptions extends Components.IonItemOptions {}

property ionSwipe

ionSwipe: EventEmitter<CustomEvent<any>>;

Emitted when the item has been fully swiped.

interface IonItemSliding

interface IonItemSliding extends Components.IonItemSliding {}

property ionDrag

ionDrag: EventEmitter<CustomEvent<any>>;

Emitted when the sliding position changes.

interface IonLabel

interface IonLabel extends Components.IonLabel {}

interface IonList

interface IonList extends Components.IonList {}

interface IonListHeader

interface IonListHeader extends Components.IonListHeader {}

interface IonLoading

interface IonLoading extends Components.IonLoading {}

property didDismiss

didDismiss: EventEmitter<CustomEvent<IIonLoadingOverlayEventDetail>>;

Emitted after the loading indicator has dismissed. Shorthand for ionLoadingDidDismiss.

property didPresent

didPresent: EventEmitter<CustomEvent<void>>;

Emitted after the loading indicator has presented. Shorthand for ionLoadingWillDismiss.

property ionLoadingDidDismiss

ionLoadingDidDismiss: EventEmitter<CustomEvent<IIonLoadingOverlayEventDetail>>;

Emitted after the loading has dismissed.

property ionLoadingDidPresent

ionLoadingDidPresent: EventEmitter<CustomEvent<void>>;

Emitted after the loading has presented.

property ionLoadingWillDismiss

ionLoadingWillDismiss: EventEmitter<CustomEvent<IIonLoadingOverlayEventDetail>>;

Emitted before the loading has dismissed.

property ionLoadingWillPresent

ionLoadingWillPresent: EventEmitter<CustomEvent<void>>;

Emitted before the loading has presented.

property willDismiss

willDismiss: EventEmitter<CustomEvent<IIonLoadingOverlayEventDetail>>;

Emitted before the loading indicator has dismissed. Shorthand for ionLoadingWillDismiss.

property willPresent

willPresent: EventEmitter<CustomEvent<void>>;

Emitted before the loading indicator has presented. Shorthand for ionLoadingWillPresent.

interface IonMenu

interface IonMenu extends Components.IonMenu {}

property ionDidClose

ionDidClose: EventEmitter<CustomEvent<IIonMenuMenuCloseEventDetail>>;

Emitted when the menu is closed.

property ionDidOpen

ionDidOpen: EventEmitter<CustomEvent<void>>;

Emitted when the menu is open.

property ionWillClose

ionWillClose: EventEmitter<CustomEvent<IIonMenuMenuCloseEventDetail>>;

Emitted when the menu is about to be closed.

property ionWillOpen

ionWillOpen: EventEmitter<CustomEvent<void>>;

Emitted when the menu is about to be opened.

interface IonMenuButton

interface IonMenuButton extends Components.IonMenuButton {}

interface IonMenuToggle

interface IonMenuToggle extends Components.IonMenuToggle {}

interface IonNavLink

interface IonNavLink extends Components.IonNavLink {}

interface IonNote

interface IonNote extends Components.IonNote {}

interface IonPicker

interface IonPicker extends Components.IonPicker {}

interface IonPickerColumn

interface IonPickerColumn extends Components.IonPickerColumn {}

property ionChange

ionChange: EventEmitter<
    CustomEvent<IIonPickerColumnPickerColumnChangeEventDetail>
>;

Emitted when the value has changed.
This event will not emit when programmatically setting the value property.

interface IonPickerColumnOption

interface IonPickerColumnOption extends Components.IonPickerColumnOption {}

interface IonPickerLegacy

interface IonPickerLegacy extends Components.IonPickerLegacy {}

property didDismiss

didDismiss: EventEmitter<CustomEvent<IIonPickerLegacyOverlayEventDetail>>;

Emitted after the picker has dismissed. Shorthand for ionPickerDidDismiss.

property didPresent

didPresent: EventEmitter<CustomEvent<void>>;

Emitted after the picker has presented. Shorthand for ionPickerWillDismiss.

property ionPickerDidDismiss

ionPickerDidDismiss: EventEmitter<
    CustomEvent<IIonPickerLegacyOverlayEventDetail>
>;

Emitted after the picker has dismissed.

property ionPickerDidPresent

ionPickerDidPresent: EventEmitter<CustomEvent<void>>;

Emitted after the picker has presented.

property ionPickerWillDismiss

ionPickerWillDismiss: EventEmitter<
    CustomEvent<IIonPickerLegacyOverlayEventDetail>
>;

Emitted before the picker has dismissed.

property ionPickerWillPresent

ionPickerWillPresent: EventEmitter<CustomEvent<void>>;

Emitted before the picker has presented.

property willDismiss

willDismiss: EventEmitter<CustomEvent<IIonPickerLegacyOverlayEventDetail>>;

Emitted before the picker has dismissed. Shorthand for ionPickerWillDismiss.

property willPresent

willPresent: EventEmitter<CustomEvent<void>>;

Emitted before the picker has presented. Shorthand for ionPickerWillPresent.

interface IonProgressBar

interface IonProgressBar extends Components.IonProgressBar {}

interface IonRadio

interface IonRadio extends Components.IonRadio {}

property ionBlur

ionBlur: EventEmitter<CustomEvent<void>>;

Emitted when the radio button loses focus.

property ionFocus

ionFocus: EventEmitter<CustomEvent<void>>;

Emitted when the radio button has focus.

interface IonRadioGroup

interface IonRadioGroup extends Components.IonRadioGroup {}

property ionChange

ionChange: EventEmitter<CustomEvent<IIonRadioGroupRadioGroupChangeEventDetail>>;

Emitted when the value has changed.
This event will not emit when programmatically setting the value property.

interface IonRange

interface IonRange extends Components.IonRange {}

property ionBlur

ionBlur: EventEmitter<CustomEvent<void>>;

Emitted when the range loses focus.

property ionChange

ionChange: EventEmitter<CustomEvent<IIonRangeRangeChangeEventDetail>>;

The ionChange event is fired for <ion-range> elements when the user modifies the element's value: - When the user releases the knob after dragging; - When the user moves the knob with keyboard arrows
This event will not emit when programmatically setting the value property.

property ionFocus

ionFocus: EventEmitter<CustomEvent<void>>;

Emitted when the range has focus.

property ionInput

ionInput: EventEmitter<CustomEvent<IIonRangeRangeChangeEventDetail>>;

The ionInput event is fired for <ion-range> elements when the value is modified. Unlike ionChange, ionInput is fired continuously while the user is dragging the knob.

property ionKnobMoveEnd

ionKnobMoveEnd: EventEmitter<CustomEvent<IIonRangeRangeKnobMoveEndEventDetail>>;

Emitted when the user finishes moving the range knob, whether through mouse drag, touch gesture, or keyboard interaction.

property ionKnobMoveStart

ionKnobMoveStart: EventEmitter<
    CustomEvent<IIonRangeRangeKnobMoveStartEventDetail>
>;

Emitted when the user starts moving the range knob, whether through mouse drag, touch gesture, or keyboard interaction.

interface IonRefresher

interface IonRefresher extends Components.IonRefresher {}

property ionPull

ionPull: EventEmitter<CustomEvent<void>>;

Emitted while the user is pulling down the content and exposing the refresher.

property ionRefresh

ionRefresh: EventEmitter<CustomEvent<IIonRefresherRefresherEventDetail>>;

Emitted when the user lets go of the content and has pulled down further than the pullMin or pulls the content down and exceeds the pullMax. Updates the refresher state to refreshing. The complete() method should be called when the async operation has completed.

property ionStart

ionStart: EventEmitter<CustomEvent<void>>;

Emitted when the user begins to start pulling down.

interface IonRefresherContent

interface IonRefresherContent extends Components.IonRefresherContent {}

interface IonReorder

interface IonReorder extends Components.IonReorder {}

interface IonReorderGroup

interface IonReorderGroup extends Components.IonReorderGroup {}

property ionItemReorder

ionItemReorder: EventEmitter<
    CustomEvent<IIonReorderGroupItemReorderEventDetail>
>;

Event that needs to be listened to in order to complete the reorder action. Once the event has been emitted, the complete() method then needs to be called in order to finalize the reorder action.

interface IonRippleEffect

interface IonRippleEffect extends Components.IonRippleEffect {}

interface IonRow

interface IonRow extends Components.IonRow {}

interface IonSearchbar

interface IonSearchbar extends Components.IonSearchbar {}

property ionBlur

ionBlur: EventEmitter<CustomEvent<void>>;

Emitted when the input loses focus.

property ionCancel

ionCancel: EventEmitter<CustomEvent<void>>;

Emitted when the cancel button is clicked.

property ionChange

ionChange: EventEmitter<CustomEvent<IIonSearchbarSearchbarChangeEventDetail>>;

The ionChange event is fired for <ion-searchbar> elements when the user modifies the element's value. Unlike the ionInput event, the ionChange event is not necessarily fired for each alteration to an element's value.
The ionChange event is fired when the value has been committed by the user. This can happen when the element loses focus or when the "Enter" key is pressed. ionChange can also fire when clicking the clear or cancel buttons.
This event will not emit when programmatically setting the value property.

property ionClear

ionClear: EventEmitter<CustomEvent<void>>;

Emitted when the clear input button is clicked.

property ionFocus

ionFocus: EventEmitter<CustomEvent<void>>;

Emitted when the input has focus.

property ionInput

ionInput: EventEmitter<CustomEvent<IIonSearchbarSearchbarInputEventDetail>>;

Emitted when the value of the ion-searchbar element has changed.

interface IonSegment

interface IonSegment extends Components.IonSegment {}

property ionChange

ionChange: EventEmitter<CustomEvent<IIonSegmentSegmentChangeEventDetail>>;

Emitted when the value property has changed and any dragging pointer has been released from ion-segment.
This event will not emit when programmatically setting the value property.

interface IonSegmentButton

interface IonSegmentButton extends Components.IonSegmentButton {}

interface IonSegmentContent

interface IonSegmentContent extends Components.IonSegmentContent {}

interface IonSegmentView

interface IonSegmentView extends Components.IonSegmentView {}

property ionSegmentViewScroll

ionSegmentViewScroll: EventEmitter<
    CustomEvent<IIonSegmentViewSegmentViewScrollEvent>
>;

Emitted when the segment view is scrolled.

interface IonSelect

interface IonSelect extends Components.IonSelect {}

property ionBlur

ionBlur: EventEmitter<CustomEvent<void>>;

Emitted when the select loses focus.

property ionCancel

ionCancel: EventEmitter<CustomEvent<void>>;

Emitted when the selection is cancelled.

property ionChange

ionChange: EventEmitter<CustomEvent<IIonSelectSelectChangeEventDetail>>;

Emitted when the value has changed.
This event will not emit when programmatically setting the value property.

property ionDismiss

ionDismiss: EventEmitter<CustomEvent<void>>;

Emitted when the overlay is dismissed.

property ionFocus

ionFocus: EventEmitter<CustomEvent<void>>;

Emitted when the select has focus.

interface IonSelectModal

interface IonSelectModal extends Components.IonSelectModal {}

interface IonSelectOption

interface IonSelectOption extends Components.IonSelectOption {}

interface IonSkeletonText

interface IonSkeletonText extends Components.IonSkeletonText {}

interface IonSpinner

interface IonSpinner extends Components.IonSpinner {}

interface IonSplitPane

interface IonSplitPane extends Components.IonSplitPane {}

property ionSplitPaneVisible

ionSplitPaneVisible: EventEmitter<
    CustomEvent<{
        visible: boolean;
    }>
>;

Expression to be called when the split-pane visibility has changed

interface IonTab

interface IonTab extends Components.IonTab {}

interface IonTabBar

interface IonTabBar extends Components.IonTabBar {}

interface IonTabButton

interface IonTabButton extends Components.IonTabButton {}

interface IonText

interface IonText extends Components.IonText {}

interface IonTextarea

interface IonTextarea extends Components.IonTextarea {}

property ionBlur

ionBlur: EventEmitter<CustomEvent<FocusEvent>>;

Emitted when the input loses focus.

property ionChange

ionChange: EventEmitter<CustomEvent<IIonTextareaTextareaChangeEventDetail>>;

The ionChange event is fired when the user modifies the textarea's value. Unlike the ionInput event, the ionChange event is fired when the element loses focus after its value has been modified.
This event will not emit when programmatically setting the value property.

property ionFocus

ionFocus: EventEmitter<CustomEvent<FocusEvent>>;

Emitted when the input has focus.

property ionInput

ionInput: EventEmitter<CustomEvent<IIonTextareaTextareaInputEventDetail>>;

The ionInput event is fired each time the user modifies the textarea's value. Unlike the ionChange event, the ionInput event is fired for each alteration to the textarea's value. This typically happens for each keystroke as the user types.
When clearOnEdit is enabled, the ionInput event will be fired when the user clears the textarea by performing a keydown event.

interface IonThumbnail

interface IonThumbnail extends Components.IonThumbnail {}

interface IonTitle

interface IonTitle extends Components.IonTitle {}

interface IonToast

interface IonToast extends Components.IonToast {}

property didDismiss

didDismiss: EventEmitter<CustomEvent<IIonToastOverlayEventDetail>>;

Emitted after the toast has dismissed. Shorthand for ionToastDidDismiss.

property didPresent

didPresent: EventEmitter<CustomEvent<void>>;

Emitted after the toast has presented. Shorthand for ionToastWillDismiss.

property ionToastDidDismiss

ionToastDidDismiss: EventEmitter<CustomEvent<IIonToastOverlayEventDetail>>;

Emitted after the toast has dismissed.

property ionToastDidPresent

ionToastDidPresent: EventEmitter<CustomEvent<void>>;

Emitted after the toast has presented.

property ionToastWillDismiss

ionToastWillDismiss: EventEmitter<CustomEvent<IIonToastOverlayEventDetail>>;

Emitted before the toast has dismissed.

property ionToastWillPresent

ionToastWillPresent: EventEmitter<CustomEvent<void>>;

Emitted before the toast has presented.

property willDismiss

willDismiss: EventEmitter<CustomEvent<IIonToastOverlayEventDetail>>;

Emitted before the toast has dismissed. Shorthand for ionToastWillDismiss.

property willPresent

willPresent: EventEmitter<CustomEvent<void>>;

Emitted before the toast has presented. Shorthand for ionToastWillPresent.

interface IonToggle

interface IonToggle extends Components.IonToggle {}

property ionBlur

ionBlur: EventEmitter<CustomEvent<void>>;

Emitted when the toggle loses focus.

property ionChange

ionChange: EventEmitter<CustomEvent<IIonToggleToggleChangeEventDetail>>;

Emitted when the user switches the toggle on or off.
This event will not emit when programmatically setting the checked property.

property ionFocus

ionFocus: EventEmitter<CustomEvent<void>>;

Emitted when the toggle has focus.

interface IonToolbar

interface IonToolbar extends Components.IonToolbar {}

Package Files (26)

Dependencies (4)

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (5)

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@ionic/angular.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@ionic/angular)

HTML

<a href="https://www.jsdocs.io/package/@ionic/angular"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 10 days ago.
Package analyzed in 11391 ms.
Missing or incorrect documentation? Open an issue for this package.