@ionic/angular

  • Version 8.1.2
  • Published
  • 3.17 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

Classes

Interfaces

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: HTMLElement;

                                                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: HTMLElement;

                                                            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: HTMLElement;

                                                                        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: HTMLElement;

                                                                                    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: HTMLElement;

                                                                                                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: HTMLElement;

                                                                                                            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: HTMLElement;

                                                                                                                                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: HTMLElement;

                                                                                                                                            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: HTMLElement;

                                                                                                                                                        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: HTMLElement;

                                                                                                                                                                    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: HTMLElement;

                                                                                                                                                                                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: HTMLElement;

                                                                                                                                                                                            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: HTMLElement;

                                                                                                                                                                                                        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: HTMLElement;

                                                                                                                                                                                                                    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: HTMLElement;

                                                                                                                                                                                                                                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: HTMLElement;

                                                                                                                                                                                                                                            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: HTMLElement;

                                                                                                                                                                                                                                                        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: HTMLElement;

                                                                                                                                                                                                                                                                    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 };
                                                                                                                                                                                                                                                                    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 };
                                                                                                                                                                                                                                                                    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: HTMLElement;

                                                                                                                                                                                                                                                                                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: HTMLElement;

                                                                                                                                                                                                                                                                                            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: HTMLElement;

                                                                                                                                                                                                                                                                                                        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: HTMLElement;

                                                                                                                                                                                                                                                                                                                    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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                            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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                        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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                    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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                            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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                        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.IonSelect,
                                                                                                                                                                                                                                                                                                                                                                                                                    typeof i1.IonSelectOption,
                                                                                                                                                                                                                                                                                                                                                                                                                    typeof i1.IonSkeletonText,
                                                                                                                                                                                                                                                                                                                                                                                                                    typeof i1.IonSpinner,
                                                                                                                                                                                                                                                                                                                                                                                                                    typeof i1.IonSplitPane,
                                                                                                                                                                                                                                                                                                                                                                                                                    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.IonSelect,
                                                                                                                                                                                                                                                                                                                                                                                                                    typeof i1.IonSelectOption,
                                                                                                                                                                                                                                                                                                                                                                                                                    typeof i1.IonSkeletonText,
                                                                                                                                                                                                                                                                                                                                                                                                                    typeof i1.IonSpinner,
                                                                                                                                                                                                                                                                                                                                                                                                                    typeof i1.IonSplitPane,
                                                                                                                                                                                                                                                                                                                                                                                                                    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) => ModuleWithProviders<IonicModule>;

                                                                                                                                                                                                                                                                                                                                                                                                                        class IonIcon

                                                                                                                                                                                                                                                                                                                                                                                                                        class IonIcon {}

                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                            property el

                                                                                                                                                                                                                                                                                                                                                                                                                            protected el: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                              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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                          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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property el

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected el: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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;