@ionic/angular

  • Version 7.0.9
  • Published
  • 2.47 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

Classes

Interfaces

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 AngularDelegate

                  class AngularDelegate {}

                    property ɵfac

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

                      property ɵprov

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

                        method create

                        create: (
                        environmentInjector: EnvironmentInjector,
                        injector: Injector,
                        elementReferenceKey?: string
                        ) => AngularFrameworkDelegate;

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

                                      property ɵfac

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

                                        method writeValue

                                        writeValue: (value: boolean) => void;

                                          class Config

                                          class Config {}

                                            property ɵfac

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

                                              property ɵprov

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

                                                method get

                                                get: (key: keyof IonicConfig, fallback?: any) => any;

                                                  method getBoolean

                                                  getBoolean: (key: keyof IonicConfig, fallback?: boolean) => boolean;

                                                    method getNumber

                                                    getNumber: (key: keyof IonicConfig, fallback?: number) => number;

                                                      class DomController

                                                      class DomController {}

                                                        property ɵfac

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

                                                          property ɵprov

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

                                                            method read

                                                            read: (cb: RafCallback) => void;
                                                            • Schedules a task to run during the READ phase of the next frame. This task should only read the DOM, but never modify it.

                                                            method write

                                                            write: (cb: RafCallback) => void;
                                                            • Schedules a task to run during the WRITE phase of the next frame. This task should write the DOM, but never READ it.

                                                            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: 'disabled';
                                                                          mode: 'mode';
                                                                          readonly: 'readonly';
                                                                          toggleIcon: 'toggleIcon';
                                                                          toggleIconSlot: 'toggleIconSlot';
                                                                          value: 'value';
                                                                          },
                                                                          {},
                                                                          never,
                                                                          ['*'],
                                                                          false
                                                                          >;

                                                                            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: 'animated';
                                                                                      disabled: 'disabled';
                                                                                      expand: 'expand';
                                                                                      mode: 'mode';
                                                                                      multiple: 'multiple';
                                                                                      readonly: 'readonly';
                                                                                      value: 'value';
                                                                                      },
                                                                                      {},
                                                                                      never,
                                                                                      ['*'],
                                                                                      false
                                                                                      >;

                                                                                        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: 'animated';
                                                                                                  backdropDismiss: 'backdropDismiss';
                                                                                                  buttons: 'buttons';
                                                                                                  cssClass: 'cssClass';
                                                                                                  enterAnimation: 'enterAnimation';
                                                                                                  header: 'header';
                                                                                                  htmlAttributes: 'htmlAttributes';
                                                                                                  isOpen: 'isOpen';
                                                                                                  keyboardClose: 'keyboardClose';
                                                                                                  leaveAnimation: 'leaveAnimation';
                                                                                                  mode: 'mode';
                                                                                                  subHeader: 'subHeader';
                                                                                                  translucent: 'translucent';
                                                                                                  trigger: 'trigger';
                                                                                                  },
                                                                                                  {},
                                                                                                  never,
                                                                                                  ['*'],
                                                                                                  false
                                                                                                  >;

                                                                                                    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: 'animated';
                                                                                                              backdropDismiss: 'backdropDismiss';
                                                                                                              buttons: 'buttons';
                                                                                                              cssClass: 'cssClass';
                                                                                                              enterAnimation: 'enterAnimation';
                                                                                                              header: 'header';
                                                                                                              htmlAttributes: 'htmlAttributes';
                                                                                                              inputs: 'inputs';
                                                                                                              isOpen: 'isOpen';
                                                                                                              keyboardClose: 'keyboardClose';
                                                                                                              leaveAnimation: 'leaveAnimation';
                                                                                                              message: 'message';
                                                                                                              mode: 'mode';
                                                                                                              subHeader: 'subHeader';
                                                                                                              translucent: 'translucent';
                                                                                                              trigger: 'trigger';
                                                                                                              },
                                                                                                              {},
                                                                                                              never,
                                                                                                              ['*'],
                                                                                                              false
                                                                                                              >;

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

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

                                                                                                                                        property ɵfac

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

                                                                                                                                          property z

                                                                                                                                          protected z: NgZone;

                                                                                                                                            class IonBackButton

                                                                                                                                            class IonBackButton {}

                                                                                                                                              constructor

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

                                                                                                                                                property el

                                                                                                                                                protected el: HTMLElement;

                                                                                                                                                  property ɵcmp

                                                                                                                                                  static ɵcmp: i0.ɵɵComponentDeclaration<
                                                                                                                                                  IonBackButton,
                                                                                                                                                  'ion-back-button',
                                                                                                                                                  never,
                                                                                                                                                  {
                                                                                                                                                  color: 'color';
                                                                                                                                                  defaultHref: 'defaultHref';
                                                                                                                                                  disabled: 'disabled';
                                                                                                                                                  icon: 'icon';
                                                                                                                                                  mode: 'mode';
                                                                                                                                                  routerAnimation: 'routerAnimation';
                                                                                                                                                  text: 'text';
                                                                                                                                                  type: 'type';
                                                                                                                                                  },
                                                                                                                                                  {},
                                                                                                                                                  never,
                                                                                                                                                  ['*'],
                                                                                                                                                  false
                                                                                                                                                  >;

                                                                                                                                                    property ɵfac

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

                                                                                                                                                      property z

                                                                                                                                                      protected z: NgZone;

                                                                                                                                                        class IonBackButtonDelegate

                                                                                                                                                        class IonBackButtonDelegateDirective {}

                                                                                                                                                          constructor

                                                                                                                                                          constructor(
                                                                                                                                                          routerOutlet: IonRouterOutlet,
                                                                                                                                                          navCtrl: NavController,
                                                                                                                                                          config: Config
                                                                                                                                                          );

                                                                                                                                                            property defaultHref

                                                                                                                                                            defaultHref: string;

                                                                                                                                                              property ɵdir

                                                                                                                                                              static ɵdir: i0.ɵɵDirectiveDeclaration<
                                                                                                                                                              IonBackButtonDelegateDirective,
                                                                                                                                                              'ion-back-button',
                                                                                                                                                              never,
                                                                                                                                                              { defaultHref: 'defaultHref'; routerAnimation: 'routerAnimation' },
                                                                                                                                                              {},
                                                                                                                                                              never,
                                                                                                                                                              never,
                                                                                                                                                              false
                                                                                                                                                              >;

                                                                                                                                                                property ɵfac

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

                                                                                                                                                                  property routerAnimation

                                                                                                                                                                  routerAnimation?: AnimationBuilder;

                                                                                                                                                                    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: 'stopPropagation';
                                                                                                                                                                          tappable: 'tappable';
                                                                                                                                                                          visible: 'visible';
                                                                                                                                                                          },
                                                                                                                                                                          {},
                                                                                                                                                                          never,
                                                                                                                                                                          ['*'],
                                                                                                                                                                          false
                                                                                                                                                                          >;

                                                                                                                                                                            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: 'color'; mode: 'mode' },
                                                                                                                                                                                      {},
                                                                                                                                                                                      never,
                                                                                                                                                                                      ['*'],
                                                                                                                                                                                      false
                                                                                                                                                                                      >;

                                                                                                                                                                                        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: 'active';
                                                                                                                                                                                                  color: 'color';
                                                                                                                                                                                                  disabled: 'disabled';
                                                                                                                                                                                                  download: 'download';
                                                                                                                                                                                                  href: 'href';
                                                                                                                                                                                                  mode: 'mode';
                                                                                                                                                                                                  rel: 'rel';
                                                                                                                                                                                                  routerAnimation: 'routerAnimation';
                                                                                                                                                                                                  routerDirection: 'routerDirection';
                                                                                                                                                                                                  separator: 'separator';
                                                                                                                                                                                                  target: 'target';
                                                                                                                                                                                                  },
                                                                                                                                                                                                  {},
                                                                                                                                                                                                  never,
                                                                                                                                                                                                  ['*'],
                                                                                                                                                                                                  false
                                                                                                                                                                                                  >;

                                                                                                                                                                                                    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: 'color';
                                                                                                                                                                                                              itemsAfterCollapse: 'itemsAfterCollapse';
                                                                                                                                                                                                              itemsBeforeCollapse: 'itemsBeforeCollapse';
                                                                                                                                                                                                              maxItems: 'maxItems';
                                                                                                                                                                                                              mode: 'mode';
                                                                                                                                                                                                              },
                                                                                                                                                                                                              {},
                                                                                                                                                                                                              never,
                                                                                                                                                                                                              ['*'],
                                                                                                                                                                                                              false
                                                                                                                                                                                                              >;

                                                                                                                                                                                                                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: 'buttonType';
                                                                                                                                                                                                                          color: 'color';
                                                                                                                                                                                                                          disabled: 'disabled';
                                                                                                                                                                                                                          download: 'download';
                                                                                                                                                                                                                          expand: 'expand';
                                                                                                                                                                                                                          fill: 'fill';
                                                                                                                                                                                                                          form: 'form';
                                                                                                                                                                                                                          href: 'href';
                                                                                                                                                                                                                          mode: 'mode';
                                                                                                                                                                                                                          rel: 'rel';
                                                                                                                                                                                                                          routerAnimation: 'routerAnimation';
                                                                                                                                                                                                                          routerDirection: 'routerDirection';
                                                                                                                                                                                                                          shape: 'shape';
                                                                                                                                                                                                                          size: 'size';
                                                                                                                                                                                                                          strong: 'strong';
                                                                                                                                                                                                                          target: 'target';
                                                                                                                                                                                                                          type: 'type';
                                                                                                                                                                                                                          },
                                                                                                                                                                                                                          {},
                                                                                                                                                                                                                          never,
                                                                                                                                                                                                                          ['*'],
                                                                                                                                                                                                                          false
                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                            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: 'collapse' },
                                                                                                                                                                                                                                      {},
                                                                                                                                                                                                                                      never,
                                                                                                                                                                                                                                      ['*'],
                                                                                                                                                                                                                                      false
                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                        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: 'button';
                                                                                                                                                                                                                                                  color: 'color';
                                                                                                                                                                                                                                                  disabled: 'disabled';
                                                                                                                                                                                                                                                  download: 'download';
                                                                                                                                                                                                                                                  href: 'href';
                                                                                                                                                                                                                                                  mode: 'mode';
                                                                                                                                                                                                                                                  rel: 'rel';
                                                                                                                                                                                                                                                  routerAnimation: 'routerAnimation';
                                                                                                                                                                                                                                                  routerDirection: 'routerDirection';
                                                                                                                                                                                                                                                  target: 'target';
                                                                                                                                                                                                                                                  type: 'type';
                                                                                                                                                                                                                                                  },
                                                                                                                                                                                                                                                  {},
                                                                                                                                                                                                                                                  never,
                                                                                                                                                                                                                                                  ['*'],
                                                                                                                                                                                                                                                  false
                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                    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: 'mode' },
                                                                                                                                                                                                                                                              {},
                                                                                                                                                                                                                                                              never,
                                                                                                                                                                                                                                                              ['*'],
                                                                                                                                                                                                                                                              false
                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                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: 'color'; mode: 'mode'; translucent: 'translucent' },
                                                                                                                                                                                                                                                                          {},
                                                                                                                                                                                                                                                                          never,
                                                                                                                                                                                                                                                                          ['*'],
                                                                                                                                                                                                                                                                          false
                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                            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: 'color'; mode: 'mode' },
                                                                                                                                                                                                                                                                                      {},
                                                                                                                                                                                                                                                                                      never,
                                                                                                                                                                                                                                                                                      ['*'],
                                                                                                                                                                                                                                                                                      false
                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                        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: 'color'; mode: 'mode' },
                                                                                                                                                                                                                                                                                                  {},
                                                                                                                                                                                                                                                                                                  never,
                                                                                                                                                                                                                                                                                                  ['*'],
                                                                                                                                                                                                                                                                                                  false
                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                    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,
                                                                                                                                                                                                                                                                                                              {
                                                                                                                                                                                                                                                                                                              checked: 'checked';
                                                                                                                                                                                                                                                                                                              color: 'color';
                                                                                                                                                                                                                                                                                                              disabled: 'disabled';
                                                                                                                                                                                                                                                                                                              indeterminate: 'indeterminate';
                                                                                                                                                                                                                                                                                                              justify: 'justify';
                                                                                                                                                                                                                                                                                                              labelPlacement: 'labelPlacement';
                                                                                                                                                                                                                                                                                                              legacy: 'legacy';
                                                                                                                                                                                                                                                                                                              mode: 'mode';
                                                                                                                                                                                                                                                                                                              name: 'name';
                                                                                                                                                                                                                                                                                                              value: 'value';
                                                                                                                                                                                                                                                                                                              },
                                                                                                                                                                                                                                                                                                              {},
                                                                                                                                                                                                                                                                                                              never,
                                                                                                                                                                                                                                                                                                              ['*'],
                                                                                                                                                                                                                                                                                                              false
                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                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: 'color'; disabled: 'disabled'; mode: 'mode'; outline: 'outline' },
                                                                                                                                                                                                                                                                                                                          {},
                                                                                                                                                                                                                                                                                                                          never,
                                                                                                                                                                                                                                                                                                                          ['*'],
                                                                                                                                                                                                                                                                                                                          false
                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                            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: 'offset';
                                                                                                                                                                                                                                                                                                                                      offsetLg: 'offsetLg';
                                                                                                                                                                                                                                                                                                                                      offsetMd: 'offsetMd';
                                                                                                                                                                                                                                                                                                                                      offsetSm: 'offsetSm';
                                                                                                                                                                                                                                                                                                                                      offsetXl: 'offsetXl';
                                                                                                                                                                                                                                                                                                                                      offsetXs: 'offsetXs';
                                                                                                                                                                                                                                                                                                                                      pull: 'pull';
                                                                                                                                                                                                                                                                                                                                      pullLg: 'pullLg';
                                                                                                                                                                                                                                                                                                                                      pullMd: 'pullMd';
                                                                                                                                                                                                                                                                                                                                      pullSm: 'pullSm';
                                                                                                                                                                                                                                                                                                                                      pullXl: 'pullXl';
                                                                                                                                                                                                                                                                                                                                      pullXs: 'pullXs';
                                                                                                                                                                                                                                                                                                                                      push: 'push';
                                                                                                                                                                                                                                                                                                                                      pushLg: 'pushLg';
                                                                                                                                                                                                                                                                                                                                      pushMd: 'pushMd';
                                                                                                                                                                                                                                                                                                                                      pushSm: 'pushSm';
                                                                                                                                                                                                                                                                                                                                      pushXl: 'pushXl';
                                                                                                                                                                                                                                                                                                                                      pushXs: 'pushXs';
                                                                                                                                                                                                                                                                                                                                      size: 'size';
                                                                                                                                                                                                                                                                                                                                      sizeLg: 'sizeLg';
                                                                                                                                                                                                                                                                                                                                      sizeMd: 'sizeMd';
                                                                                                                                                                                                                                                                                                                                      sizeSm: 'sizeSm';
                                                                                                                                                                                                                                                                                                                                      sizeXl: 'sizeXl';
                                                                                                                                                                                                                                                                                                                                      sizeXs: 'sizeXs';
                                                                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                                                                      {},
                                                                                                                                                                                                                                                                                                                                      never,
                                                                                                                                                                                                                                                                                                                                      ['*'],
                                                                                                                                                                                                                                                                                                                                      false
                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                        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: 'color';
                                                                                                                                                                                                                                                                                                                                                  forceOverscroll: 'forceOverscroll';
                                                                                                                                                                                                                                                                                                                                                  fullscreen: 'fullscreen';
                                                                                                                                                                                                                                                                                                                                                  scrollEvents: 'scrollEvents';
                                                                                                                                                                                                                                                                                                                                                  scrollX: 'scrollX';
                                                                                                                                                                                                                                                                                                                                                  scrollY: 'scrollY';
                                                                                                                                                                                                                                                                                                                                                  },
                                                                                                                                                                                                                                                                                                                                                  {},
                                                                                                                                                                                                                                                                                                                                                  never,
                                                                                                                                                                                                                                                                                                                                                  ['*'],
                                                                                                                                                                                                                                                                                                                                                  false
                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                    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: 'cancelText';
                                                                                                                                                                                                                                                                                                                                                              clearText: 'clearText';
                                                                                                                                                                                                                                                                                                                                                              color: 'color';
                                                                                                                                                                                                                                                                                                                                                              dayValues: 'dayValues';
                                                                                                                                                                                                                                                                                                                                                              disabled: 'disabled';
                                                                                                                                                                                                                                                                                                                                                              doneText: 'doneText';
                                                                                                                                                                                                                                                                                                                                                              firstDayOfWeek: 'firstDayOfWeek';
                                                                                                                                                                                                                                                                                                                                                              highlightedDates: 'highlightedDates';
                                                                                                                                                                                                                                                                                                                                                              hourCycle: 'hourCycle';
                                                                                                                                                                                                                                                                                                                                                              hourValues: 'hourValues';
                                                                                                                                                                                                                                                                                                                                                              isDateEnabled: 'isDateEnabled';
                                                                                                                                                                                                                                                                                                                                                              locale: 'locale';
                                                                                                                                                                                                                                                                                                                                                              max: 'max';
                                                                                                                                                                                                                                                                                                                                                              min: 'min';
                                                                                                                                                                                                                                                                                                                                                              minuteValues: 'minuteValues';
                                                                                                                                                                                                                                                                                                                                                              mode: 'mode';
                                                                                                                                                                                                                                                                                                                                                              monthValues: 'monthValues';
                                                                                                                                                                                                                                                                                                                                                              multiple: 'multiple';
                                                                                                                                                                                                                                                                                                                                                              name: 'name';
                                                                                                                                                                                                                                                                                                                                                              preferWheel: 'preferWheel';
                                                                                                                                                                                                                                                                                                                                                              presentation: 'presentation';
                                                                                                                                                                                                                                                                                                                                                              readonly: 'readonly';
                                                                                                                                                                                                                                                                                                                                                              showClearButton: 'showClearButton';
                                                                                                                                                                                                                                                                                                                                                              showDefaultButtons: 'showDefaultButtons';
                                                                                                                                                                                                                                                                                                                                                              showDefaultTimeLabel: 'showDefaultTimeLabel';
                                                                                                                                                                                                                                                                                                                                                              showDefaultTitle: 'showDefaultTitle';
                                                                                                                                                                                                                                                                                                                                                              size: 'size';
                                                                                                                                                                                                                                                                                                                                                              titleSelectedDatesFormatter: 'titleSelectedDatesFormatter';
                                                                                                                                                                                                                                                                                                                                                              value: 'value';
                                                                                                                                                                                                                                                                                                                                                              yearValues: 'yearValues';
                                                                                                                                                                                                                                                                                                                                                              },
                                                                                                                                                                                                                                                                                                                                                              {},
                                                                                                                                                                                                                                                                                                                                                              never,
                                                                                                                                                                                                                                                                                                                                                              ['*'],
                                                                                                                                                                                                                                                                                                                                                              false
                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                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: 'color'; datetime: 'datetime'; disabled: 'disabled'; mode: 'mode' },
                                                                                                                                                                                                                                                                                                                                                                          {},
                                                                                                                                                                                                                                                                                                                                                                          never,
                                                                                                                                                                                                                                                                                                                                                                          ['*'],
                                                                                                                                                                                                                                                                                                                                                                          false
                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                            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: 'activated';
                                                                                                                                                                                                                                                                                                                                                                                      edge: 'edge';
                                                                                                                                                                                                                                                                                                                                                                                      horizontal: 'horizontal';
                                                                                                                                                                                                                                                                                                                                                                                      vertical: 'vertical';
                                                                                                                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                                                                                                                      {},
                                                                                                                                                                                                                                                                                                                                                                                      never,
                                                                                                                                                                                                                                                                                                                                                                                      ['*'],
                                                                                                                                                                                                                                                                                                                                                                                      false
                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                        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: 'activated';
                                                                                                                                                                                                                                                                                                                                                                                                  closeIcon: 'closeIcon';
                                                                                                                                                                                                                                                                                                                                                                                                  color: 'color';
                                                                                                                                                                                                                                                                                                                                                                                                  disabled: 'disabled';
                                                                                                                                                                                                                                                                                                                                                                                                  download: 'download';
                                                                                                                                                                                                                                                                                                                                                                                                  href: 'href';
                                                                                                                                                                                                                                                                                                                                                                                                  mode: 'mode';
                                                                                                                                                                                                                                                                                                                                                                                                  rel: 'rel';
                                                                                                                                                                                                                                                                                                                                                                                                  routerAnimation: 'routerAnimation';
                                                                                                                                                                                                                                                                                                                                                                                                  routerDirection: 'routerDirection';
                                                                                                                                                                                                                                                                                                                                                                                                  show: 'show';
                                                                                                                                                                                                                                                                                                                                                                                                  size: 'size';
                                                                                                                                                                                                                                                                                                                                                                                                  target: 'target';
                                                                                                                                                                                                                                                                                                                                                                                                  translucent: 'translucent';
                                                                                                                                                                                                                                                                                                                                                                                                  type: 'type';
                                                                                                                                                                                                                                                                                                                                                                                                  },
                                                                                                                                                                                                                                                                                                                                                                                                  {},
                                                                                                                                                                                                                                                                                                                                                                                                  never,
                                                                                                                                                                                                                                                                                                                                                                                                  ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                  false
                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                    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: 'activated'; side: 'side' },
                                                                                                                                                                                                                                                                                                                                                                                                              {},
                                                                                                                                                                                                                                                                                                                                                                                                              never,
                                                                                                                                                                                                                                                                                                                                                                                                              ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                              false
                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                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: 'collapse'; mode: 'mode'; translucent: 'translucent' },
                                                                                                                                                                                                                                                                                                                                                                                                                          {},
                                                                                                                                                                                                                                                                                                                                                                                                                          never,
                                                                                                                                                                                                                                                                                                                                                                                                                          ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                          false
                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                            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: 'fixed' },
                                                                                                                                                                                                                                                                                                                                                                                                                                      {},
                                                                                                                                                                                                                                                                                                                                                                                                                                      never,
                                                                                                                                                                                                                                                                                                                                                                                                                                      ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                      false
                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                        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: 'collapse'; mode: 'mode'; translucent: 'translucent' },
                                                                                                                                                                                                                                                                                                                                                                                                                                                  {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                  never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                  false
                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    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.IonBackButton,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              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.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.IonNav,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i1.IonNavLink,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i1.IonNote,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i1.IonPicker,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              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.RadioValueAccessorDirective,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i7.SelectValueAccessorDirective,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i8.TextValueAccessorDirective,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i9.IonTabs,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i10.IonRouterOutlet,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i11.IonBackButtonDelegateDirective,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i12.NavDelegate,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i13.RouterLinkDelegateDirective,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i13.RouterLinkWithHrefDelegateDirective
                                                                                                                                                                                                                                                                                                                                                                                                                                                              ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                              [any],
                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i1.IonAccordion,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i1.IonAccordionGroup,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i1.IonActionSheet,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i1.IonAlert,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i1.IonApp,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i1.IonAvatar,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i1.IonBackButton,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              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.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.IonNav,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i1.IonNavLink,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i1.IonNote,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i1.IonPicker,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              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.RadioValueAccessorDirective,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i7.SelectValueAccessorDirective,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i8.TextValueAccessorDirective,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i9.IonTabs,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i10.IonRouterOutlet,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i11.IonBackButtonDelegateDirective,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i12.NavDelegate,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i13.RouterLinkDelegateDirective,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeof i13.RouterLinkWithHrefDelegateDirective
                                                                                                                                                                                                                                                                                                                                                                                                                                                              ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                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: 'color';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        flipRtl: 'flipRtl';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        icon: 'icon';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ios: 'ios';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        lazy: 'lazy';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        md: 'md';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mode: 'mode';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: 'name';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sanitize: 'sanitize';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        size: 'size';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        src: 'src';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ɵfac

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property z

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected z: NgZone;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class IonicRouteStrategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class IonicRouteStrategy implements RouteReuseStrategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method retrieve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                retrieve: (_route: ActivatedRouteSnapshot) => DetachedRouteHandle | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method shouldAttach

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  shouldAttach: (_route: ActivatedRouteSnapshot) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method shouldDetach

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    shouldDetach: (_route: ActivatedRouteSnapshot) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method shouldReuseRoute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      shouldReuseRoute: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      future: ActivatedRouteSnapshot,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      curr: ActivatedRouteSnapshot
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method store

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        store: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _route: ActivatedRouteSnapshot,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _detachedTree: DetachedRouteHandle
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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: 'alt'; src: 'src' },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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: 'disabled'; position: 'position'; threshold: 'threshold' },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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: 'loadingSpinner'; loadingText: 'loadingText' },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    accept: 'accept';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    autocapitalize: 'autocapitalize';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    autocomplete: 'autocomplete';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    autocorrect: 'autocorrect';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    autofocus: 'autofocus';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    clearInput: 'clearInput';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    clearOnEdit: 'clearOnEdit';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    color: 'color';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    counter: 'counter';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    counterFormatter: 'counterFormatter';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    debounce: 'debounce';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    disabled: 'disabled';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enterkeyhint: 'enterkeyhint';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    errorText: 'errorText';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fill: 'fill';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    helperText: 'helperText';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    inputmode: 'inputmode';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    label: 'label';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    labelPlacement: 'labelPlacement';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    legacy: 'legacy';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    max: 'max';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    maxlength: 'maxlength';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    min: 'min';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    minlength: 'minlength';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mode: 'mode';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    multiple: 'multiple';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: 'name';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pattern: 'pattern';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    placeholder: 'placeholder';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly: 'readonly';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    required: 'required';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    shape: 'shape';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    size: 'size';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    spellcheck: 'spellcheck';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    step: 'step';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'type';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: 'value';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ɵfac

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static ɵfac: i0.ɵɵFactoryDeclaration<IonInput, 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: 'button';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                color: 'color';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                counter: 'counter';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                counterFormatter: 'counterFormatter';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                detail: 'detail';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                detailIcon: 'detailIcon';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                disabled: 'disabled';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                download: 'download';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fill: 'fill';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                href: 'href';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                lines: 'lines';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mode: 'mode';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                rel: 'rel';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                routerAnimation: 'routerAnimation';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                routerDirection: 'routerDirection';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                shape: 'shape';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                target: 'target';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'type';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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: 'color'; mode: 'mode'; sticky: 'sticky' },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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: 'color';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    disabled: 'disabled';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    download: 'download';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    expandable: 'expandable';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    href: 'href';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mode: 'mode';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rel: 'rel';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    target: 'target';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'type';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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: 'side' },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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: 'disabled' },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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: 'color'; mode: 'mode'; position: 'position' },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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: 'inset'; lines: 'lines'; mode: 'mode' },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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: 'color'; lines: 'lines'; mode: 'mode' },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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: 'animated';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            backdropDismiss: 'backdropDismiss';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cssClass: 'cssClass';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            duration: 'duration';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enterAnimation: 'enterAnimation';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            htmlAttributes: 'htmlAttributes';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isOpen: 'isOpen';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            keyboardClose: 'keyboardClose';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            leaveAnimation: 'leaveAnimation';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            message: 'message';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            mode: 'mode';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            showBackdrop: 'showBackdrop';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            spinner: 'spinner';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            translucent: 'translucent';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            trigger: 'trigger';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ɵfac

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property z

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected z: NgZone;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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: 'contentId';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        disabled: 'disabled';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        maxEdgeStart: 'maxEdgeStart';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        menuId: 'menuId';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        side: 'side';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        swipeGesture: 'swipeGesture';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'type';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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: 'autoHide';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    color: 'color';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    disabled: 'disabled';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    menu: 'menu';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mode: 'mode';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'type';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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: 'autoHide'; menu: 'menu' },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ɵfac

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property z

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected z: NgZone;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class IonModal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class IonModal {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property el

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected el: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isCmpOpen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isCmpOpen: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ɵcmp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static ɵcmp: i0.ɵɵComponentDeclaration<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              IonModal,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              'ion-modal',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              animated: 'animated';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              keepContentsMounted: 'keepContentsMounted';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              backdropBreakpoint: 'backdropBreakpoint';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              backdropDismiss: 'backdropDismiss';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              breakpoints: 'breakpoints';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              canDismiss: 'canDismiss';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cssClass: 'cssClass';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enterAnimation: 'enterAnimation';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              event: 'event';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              handle: 'handle';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              handleBehavior: 'handleBehavior';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              initialBreakpoint: 'initialBreakpoint';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isOpen: 'isOpen';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              keyboardClose: 'keyboardClose';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              leaveAnimation: 'leaveAnimation';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mode: 'mode';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              presentingElement: 'presentingElement';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              showBackdrop: 'showBackdrop';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              translucent: 'translucent';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              trigger: 'trigger';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ['template'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ɵfac

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property template

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  template: TemplateRef<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property z

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected z: NgZone;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class IonNav

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class IonNav {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property el

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected el: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ɵcmp

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ɵfac

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property z

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected z: NgZone;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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: 'component';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        componentProps: 'componentProps';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        routerAnimation: 'routerAnimation';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        routerDirection: 'routerDirection';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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: 'color'; mode: 'mode' },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                animated: 'animated';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                backdropDismiss: 'backdropDismiss';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                buttons: 'buttons';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                columns: 'columns';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cssClass: 'cssClass';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                duration: 'duration';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enterAnimation: 'enterAnimation';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                htmlAttributes: 'htmlAttributes';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isOpen: 'isOpen';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                keyboardClose: 'keyboardClose';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                leaveAnimation: 'leaveAnimation';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mode: 'mode';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                showBackdrop: 'showBackdrop';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                trigger: 'trigger';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ['*'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ɵfac

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property z

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected z: NgZone;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class IonPopover

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class IonPopover {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property el

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected el: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isCmpOpen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isCmpOpen: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ɵcmp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static ɵcmp: i0.ɵɵComponentDeclaration<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              IonPopover,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              'ion-popover',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              alignment: 'alignment';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              animated: 'animated';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              arrow: 'arrow';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              keepContentsMounted: 'keepContentsMounted';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              backdropDismiss: 'backdropDismiss';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cssClass: 'cssClass';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dismissOnSelect: 'dismissOnSelect';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enterAnimation: 'enterAnimation';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              event: 'event';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isOpen: 'isOpen';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              keyboardClose: 'keyboardClose';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              leaveAnimation: 'leaveAnimation';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mode: 'mode';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              showBackdrop: 'showBackdrop';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              translucent: 'translucent';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              trigger: 'trigger';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              triggerAction: 'triggerAction';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reference: 'reference';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              size: 'size';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              side: 'side';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ['template'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ɵfac

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property template

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  template: TemplateRef<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property z

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected z: NgZone;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class IonProgressBar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class IonProgressBar {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property el

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected el: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ɵcmp

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ɵfac

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property z

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected z: NgZone;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class IonRadio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class IonRadio {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property el

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected el: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ɵcmp

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ɵfac

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property z

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected z: NgZone;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class IonRadioGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class IonRadioGroup {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property el

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected el: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ɵcmp

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ɵfac

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property z

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected z: NgZone;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class IonRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class IonRange {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property el

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected el: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ɵcmp

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ɵfac

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property z

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected z: NgZone;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class IonRefresher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class IonRefresher {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property el

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected el: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ɵcmp

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ɵfac

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property z

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected z: NgZone;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class IonRefresherContent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class IonRefresherContent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property el

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected el: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ɵcmp

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ɵfac

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property z

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected z: NgZone;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class IonReorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class IonReorder {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property el

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected el: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ɵcmp

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ɵfac

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property z

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected z: NgZone;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class IonReorderGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class IonReorderGroup {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property el

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected el: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ɵcmp

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ɵfac

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property z

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected z: NgZone;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class IonRippleEffect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class IonRippleEffect {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property el

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected el: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ɵcmp

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ɵfac

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property z

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected z: NgZone;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class IonRouterOutlet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class IonRouterOutlet implements OnDestroy, OnInit {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property activatedRoute